Java 并发: 倒计时锁存与循环屏障

当我研究闩锁和自行车障碍时，我想到了这个比喻。 自行车障碍 : 想象一下，一家公司有一个会议室。为了开会，必须有一定数量的与会者来参加会议(使会议正式开始)。下面是正常与会者(员工)的代码

class MeetingAtendee implements Runnable {


CyclicBarrier myMeetingQuorumBarrier;


public MeetingAtendee(CyclicBarrier myMileStoneBarrier) {
this.myMeetingQuorumBarrier = myMileStoneBarrier;
}


@Override
public void run() {
try {
System.out.println(Thread.currentThread().getName() + " i joined the meeting ...");
myMeetingQuorumBarrier.await();
System.out.println(Thread.currentThread().getName()+" finally meeting stared ...");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
System.out.println("Meeting canceled! every body dance <by chic band!>");
}
}
}

员工参加会议，等别人来开会。如果会议被取消，他也会退出:)然后我们有老板，他不喜欢等待别人的出现，如果他失去了他的病人，他取消会议。

class MeetingAtendeeTheBoss implements Runnable {


CyclicBarrier myMeetingQuorumBarrier;


public MeetingAtendeeTheBoss(CyclicBarrier myMileStoneBarrier) {
this.myMeetingQuorumBarrier = myMileStoneBarrier;
}


@Override
public void run() {
try {
System.out.println(Thread.currentThread().getName() + "I am THE BOSS - i joined the meeting ...");
//boss dose not like to wait too much!! he/she waits for 2 seconds and we END the meeting
myMeetingQuorumBarrier.await(1,TimeUnit.SECONDS);
System.out.println(Thread.currentThread().getName()+" finally meeting stared ...");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
System.out.println("what WHO canceled The meeting");
} catch (TimeoutException e) {
System.out.println("These employees waste my time!!");
}
}
}

在平常的一天，员工来开会等待其他人的出现，如果一些与会者没有来，他们必须无限期地等待！在一些特别会议上，老板来了，他不喜欢等待。(5个人需要开会，但只有老板和一个热情的员工来了) ，所以他取消了会议(生气)

CyclicBarrier meetingAtendeeQuorum = new CyclicBarrier(5);
Thread atendeeThread = new Thread(new MeetingAtendee(meetingAtendeeQuorum));
Thread atendeeThreadBoss = new Thread(new MeetingAtendeeTheBoss(meetingAtendeeQuorum));
atendeeThread.start();
atendeeThreadBoss.start();

产出:

//Thread-1I am THE BOSS - i joined the meeting ...
// Thread-0 i joined the meeting ...
// These employees waste my time!!
// Meeting canceled! every body dance <by chic band!>

还有一种情况是，另一个外部线程(地震)取消了会议(调用重置方法)。在这种情况下，所有等待的线程都会被异常唤醒。

class NaturalDisasters implements Runnable {


CyclicBarrier someStupidMeetingAtendeeQuorum;


public NaturalDisasters(CyclicBarrier someStupidMeetingAtendeeQuorum) {
this.someStupidMeetingAtendeeQuorum = someStupidMeetingAtendeeQuorum;
}


void earthQuakeHappening(){
System.out.println("earth quaking.....");
someStupidMeetingAtendeeQuorum.reset();
}


@Override
public void run() {
earthQuakeHappening();
}
}

运行代码会导致有趣的输出:

// Thread-1I am THE BOSS - i joined the meeting ...
// Thread-0 i joined the meeting ...
// earth quaking.....
// what WHO canceled The meeting
// Meeting canceled! every body dance <by chic band!>

你也可以在会议室增加一个秘书，如果一个会议正在举行，她会记录下所有的事情，但是她不是会议的一部分:

class MeetingSecretary implements Runnable {


@Override
public void run() {
System.out.println("preparing meeting documents");
System.out.println("taking notes ...");
}
}

锁具 : 如果愤怒的老板想为公司客户举办展览会，一切都需要准备好(资源)。我们提供了一个待办事项清单每个工人(线程)剂量他的工作，我们检查待办事项清单(一些工人做油漆，其他人准备音响系统...)。当待办事项列表中的所有项目完成后(资源已提供) ，我们可以向客户敞开大门。

public class Visitor implements Runnable{


CountDownLatch exhibitonDoorlatch = null;


public Visitor (CountDownLatch latch) {
exhibitonDoorlatch  = latch;
}


public void run() {
try {
exhibitonDoorlatch .await();
} catch (InterruptedException e) {
e.printStackTrace();
}


System.out.println("customer visiting exebition");
}
}

工人们是如何准备展览的:

class Worker implements Runnable {


CountDownLatch myTodoItem = null;


public Worker(CountDownLatch latch) {
this.myTodoItem = latch;
}


public void run() {
System.out.println("doing my part of job ...");
System.out.println("My work is done! remove it from todo list");
myTodoItem.countDown();
}
}


CountDownLatch preperationTodoList = new CountDownLatch(3);


// exhibition preparation workers
Worker      electricalWorker      = new Worker(preperationTodoList);
Worker      paintingWorker      = new Worker(preperationTodoList);


// Exhibition Visitors
ExhibitionVisitor exhibitionVisitorA = new ExhibitionVisitor(preperationTodoList);
ExhibitionVisitor exhibitionVisitorB = new ExhibitionVisitor(preperationTodoList);
ExhibitionVisitor exhibitionVisitorC = new ExhibitionVisitor(preperationTodoList);


new Thread(electricalWorker).start();
new Thread(paintingWorker).start();


new Thread(exhibitionVisitorA).start();
new Thread(exhibitionVisitorB).start();
new Thread(exhibitionVisitorC).start();

CountDownLatch 是任何东西的倒计时; CyclicBlock 是仅针对线程的倒计时

假设有5个工人线程和一个托运人线程，当工人生产100个项目，托运人将发货出去。

对于 CountDownLatch，计数器可以位于 worker 或 item 上

周期障碍，计数器只能对工人

如果一个工作人员陷入无限的睡眠，使用 CountDownLatch 对项目，Shipper 可以发货; 但是，使用 CyclicBlock，Shipper 永远不能被调用

@ Kevin Lee 和@Jon 我尝试了可选的 Cyclic堰塞。看起来像是在开始和循环障碍被推倒之后运行的。这是代码和输出

静态循环屏障;

    public static void main(String[] args) throws InterruptedException {
barrier = new CyclicBarrier(3, new Runnable() {
@Override
public void run() {
System.out.println("I run in the beginning and after the CyclicBarrier is tipped");
}
});


new Worker().start();
Thread.sleep(1000);
new Worker().start();
Thread.sleep(1000);
new Worker().start();
Thread.sleep(1000);


System.out.println("Barrier automatically resets.");


new Worker().start();
Thread.sleep(1000);
new Worker().start();
Thread.sleep(1000);
new Worker().start();
}

输出

I run in the beginning and after the CyclicBarrier is tipped
Let's play.
Let's play.
Let's play.
Barrier automatically resets.
I run in the beginning and after the CyclicBarrier is tipped
Let's play.
Let's play.
Let's play.