CountDownLatch和CyclicBarrier

CoutDownLatch

• 关键函数：
  • countDown（）
  • await（）
• 目的：在N个线程都执行完成时，调用latch.await()方法的线程再执行一段逻辑，否则就一直等在latch.await()的地方。
• 用法示例：

/** 
 * 工人类 
 * 
 */  
class Worker {  
    private String name;        // 名字  
    private long workDuration;  // 工作持续时间  
  
    /** 
     * 构造器 
     */  
    public Worker(String name, long workDuration) {  
        this.name = name;  
        this.workDuration = workDuration;  
    }  
  
    /** 
     * 完成工作 
     */  
    public void doWork() {  
        System.out.println(name + " begins to work...");  
        try {  
            Thread.sleep(workDuration); // 用休眠模拟工作执行的时间  
        } catch(InterruptedException ex) {  
            ex.printStackTrace();  
        }  
        System.out.println(name + " has finished the job...");  
    }  
}  
  
/** 
 * 测试线程 
 * 
 */  
class WorkerTestThread implements Runnable {  
    private Worker worker;  
    private CountDownLatch cdLatch;  
  
    public WorkerTestThread(Worker worker, CountDownLatch cdLatch) {  
        this.worker = worker;  
        this.cdLatch = cdLatch;  
    }  
  
    @Override  
    public void run() {  
        worker.doWork();        // 让工人开始工作  
        cdLatch.countDown();    // 工作完成后倒计时次数减1  
    }  
}  
  
class CountDownLatchTest {  
  
    private static final int MAX_WORK_DURATION = 5000;  // 最大工作时间  
    private static final int MIN_WORK_DURATION = 1000;  // 最小工作时间  
  
    // 产生随机的工作时间  
    private static long getRandomWorkDuration(long min, long max) {  
        return (long) (Math.random() * (max - min) + min);  
    }  
  
    public static void main(String[] args) {  
        CountDownLatch latch = new CountDownLatch(2);   // 创建倒计时闩并指定倒计时次数为2  
        Worker w1 = new Worker("代码李", getRandomWorkDuration(MIN_WORK_DURATION, MAX_WORK_DURATION));  
        Worker w2 = new Worker("王大锤", getRandomWorkDuration(MIN_WORK_DURATION, MAX_WORK_DURATION));  
  
        new Thread(new WorkerTestThread(w1, latch)).start();  
        new Thread(new WorkerTestThread(w2, latch)).start();  
  
        try {  
            latch.await();  // 等待倒计时闩减到0  
            System.out.println("All jobs have been finished!");  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
}

CyclicBarrier

• 关键函数：
  • 构造函数可以指定一个runnable，在N个线程都启动以后执行。
  • await（）
• 目的：让N个线程都被启动了以后，再执行一个逻辑，然后再唤醒之前所有在等待的线程。如果有一个线程没有被启动，其他所有调用await（）的线程都会等待。
• 用法示例：

public class TestCyclicBarrier {

    private static final int THREAD_NUM = 5;
    
    public static class WorkerThread implements Runnable{

        CyclicBarrier barrier;
        
        public WorkerThread(CyclicBarrier b){
            this.barrier = b;
        }
        
        @Override
        public void run() {
            // TODO Auto-generated method stub
            try{
                System.out.println("Worker's waiting");
                //线程在这里等待，直到所有线程都到达barrier。
                barrier.await();
                System.out.println("ID:"+Thread.currentThread().getId()+" Working");
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        
    }
    
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        CyclicBarrier cb = new CyclicBarrier(THREAD_NUM, new Runnable() {
            //当所有线程到达barrier时执行
            @Override
            public void run() {
                // TODO Auto-generated method stub
                System.out.println("Inside Barrier");
                
            }
        });
        
        for(int i=0;i<THREAD_NUM;i++){
            new Thread(new WorkerThread(cb)).start();
        }
    }

}
/*
以下是输出：
Worker's waiting
Worker's waiting
Worker's waiting
Worker's waiting
Worker's waiting
Inside Barrier
ID:12 Working
ID:8 Working
ID:11 Working
ID:9 Working
ID:10 Working
*/