Countdownlatch与CyclicBarrier

CountDownLatch : 一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行。 CyclicBarrier : N个线程相互等待，任何一个线程完成之前，所有的线程都必须等待。
这样应该就清楚一点了，对于CountDownLatch来说，重点是那个“一个线程”, 是它在等待， 而另外那N的线程在把“某个事情”做完之后可以继续等待，可以终止。而对于CyclicBarrier来说，重点是那N个线程，他们之间任何一个没有完成，所有的线程都必须等待。

CountDownLatch：

package com.guozz.test.testCountDownLatchAndCyclicBarrier;
 
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
 
/**
 * 
 * @author paul
 * 
 * CountDownLatch 很适合用来将一个任务分为n个独立的部分，等这些部分都完成后继续接下来的任务，
 * CountDownLatch 只能出发一次，计数值不能被重置。
 * 
 * 基于CountDownLatch 的模拟项目，一个项目可以分为多个模块，只有但这些模块都完成后才可以继续下一步的工作。
 * 
 * 
 *  countDown方法，当前线程调用此方法，则计数减一
    await方法，调用此方法会一直阻塞当前线程，直到计时器的值为0
    
    executorService.shutdown() 并不是终止线程的运行，而是禁止在这个Executor中添加新的任务
     void shutdown()
        启动一个关闭命令，不再接受新任务，当所有已提交任务执行完后，就关闭。如果已经关闭，则调用没有其他作用。
        抛出：
        SecurityException - 如果安全管理器存在并且关闭，此 ExecutorService 可能操作某些不允许调用者修改的线程
                       （因为它没有保持 RuntimePermission("modifyThread")），或者安全管理器的 checkAccess 方法拒绝访问。
 */
public class CountDownLatchTest {
    //定义计数器
    static  final int  SIZE=20;
    
    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(SIZE);
        Random random = new Random();
        ExecutorService executorService = Executors.newCachedThreadPool();
        //让等待所有子线程执行完毕
        Controller controller = new Controller(latch);
        executorService.execute(controller);
        
        //将SIZE个小任务去执行，多个子线程任务
        for(int i=0;i<SIZE;i++){
            executorService.execute(new Module(latch,"模块"+(i+1),random.nextInt(2000)));
        }
        executorService.shutdown();//并不是终止线程的运行，而是禁止在这个Executor中添加新的任务
    }
}
 
 
class Module implements Runnable{
    
    private CountDownLatch latch;
    
    private String name;
    
    private int random;
    
    public Module(CountDownLatch latch,String name,int random){
        this.latch=latch;
        this.name=name;
        this.random=random;
    }
 
    @Override
    public void run() {
        work();     
        latch.countDown(); //当前线程调用此方法，则计数减一
        
    }
 
    private void work() {
         try {
            TimeUnit.MILLISECONDS.sleep(random);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }  
           System.out.println(name + " 完成，耗时:" + random);
    }
}
 
 
class Controller implements Runnable{
    
    private CountDownLatch latch;
    
    public Controller(CountDownLatch latch){
        super();
        this.latch=latch;
    }
 
    @Override
    public void run() {
        try {
            latch.await();  //调用此方法会一直阻塞当前线程，直到计时器的值为0
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("所有任务都完成，任务完成");         
    }
}

CyclicBarrier

package com.guozz.test.testCountDownLatchAndCyclicBarrier;
 
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
/**
 * 
 * @author HardPass
 * 
 * CyclicBarrier:一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。
 *  在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。
 * 因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。
    CyclicBarrier可以多次重复使用
 */
public class CyclicBarrierTest_RelayRace {
 
    public static void main(String[] args) throws InterruptedException {
        
        ExecutorService exec = Executors.newCachedThreadPool();
        
        final CyclicBarrier barrier = new CyclicBarrier(4, new Runnable() {
 
            @Override
            public void run() {
                System.out.println("好了，大家可以去吃饭了……"  );
            }
        });     
        
        System.out.println("要吃饭，必须所有人都到终点，oK?");                
        System.out.println("不放弃不抛弃！");
        
        for (int i = 0; i < 4; i++) {
            exec.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":Go");
                    try {
                        Thread.sleep((long) (2000 * Math.random()));
                    } catch (InterruptedException e1) {
                        e1.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+ ":我到终点了");
                    try {
                        barrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                    
                    System.out.println(Thread.currentThread().getName()+ ":终于可以吃饭啦！");
 
                }
            });
 
        }
        exec.shutdown();
                
    }
    
    
 
}