闭锁（CountDownLatch）与栅栏（CyclicBarrier）的区别

闭锁：一个同步工具类，闭锁的作用相当于一扇门：在闭锁到达结束状态之前，这扇门一直是关闭的，并且没有任何线程能通过，当到达结束状态时，这扇门会打开并允许所有的线程通过。当闭锁到达结束状态后将不会再改变状态，因此这扇门将永远保持打开状态。

CountDownLatch是一种灵活的闭锁实现，闭锁状态包括一个计数器，该计数器被初始化为一个正数，表示需要等待的事件数量。countDown方法递减计数器，表示有一个事件已经发生了，而await方法等待计数器达到零，这表示所有需要等待的事件都已经发生。如果计数器的值非零，那么await会一直阻塞直到计数器为零，或者等待中的线程中断，或者等待超时。

栅栏：一个同步工具类，它允许一组线程互相等待，直到到达某个公共屏障点。利用栅栏，可以使线程相互等待，直到所有线程都到达某一点，然后栅栏将打开，所有线程将通过栅栏继续执行。

CyclicBarrier支持一个可选的 Runnable 参数，当线程通过栅栏时，runnable对象将被调用。构造函数CyclicBarrier(int parties, Runnable barrierAction)，当线程在CyclicBarrier对象上调用await()方法时，栅栏的计数器将增加1，当计数器为parties时，栅栏将打开。

区别：闭锁用于所有线程等待一个外部事件的发生；栅栏则是所有线程相互等待，直到所有线程都到达某一点时才打开栅栏，然后线程可以继续执行。
1.CountDownLatch减计数，CyclicBarrier加计数。
2.CountDownLatch是一次性的，CyclicBarrier可以重用

示例：引用自http://aaron-han.iteye.com/blog/1591755

1. 有五个人，一个裁判。这五个人同时跑，裁判开始计时，五个人都到终点了，裁判喊停，然后统计这五个人从开始跑到最后一个撞线用了多长时间。

    import java.util.concurrent.CountDownLatch;  
      
    public class Race {  
      
        public static void main(String[] args) {  
            final int num = 5;  
            final CountDownLatch begin = new CountDownLatch(1);  
            final CountDownLatch end = new CountDownLatch(num);  
      
            for (int i = 0; i < num; i++) {  
                new Thread(new AWorker(i, begin, end)).start();  
            }  
      
            // judge prepare...  
            try {  
                Thread.sleep((long) (Math.random() * 5000));  
            } catch (InterruptedException e1) {  
                e1.printStackTrace();  
            }  
      
            System.out.println("judge say : run !");  
            begin.countDown();  
            long startTime = System.currentTimeMillis();  
      
            try {  
                end.await();  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            } finally {  
                long endTime = System.currentTimeMillis();  
                System.out.println("judge say : all arrived !");  
                System.out.println("spend time: " + (endTime - startTime));  
            }  
      
        }  
      
    }  
      
    class AWorker implements Runnable {  
        final CountDownLatch begin;  
        final CountDownLatch end;  
        final int id;  
      
        public AWorker(final int id, final CountDownLatch begin,  
                final CountDownLatch end) {  
            this.id = id;  
            this.begin = begin;  
            this.end = end;  
        }  
      
        @Override  
        public void run() {  
            try {  
                System.out.println(this.id + " ready !");  
                begin.await();  
                // run...  
                Thread.sleep((long) (Math.random() * 10000));  
            } catch (Throwable e) {  
                e.printStackTrace();  
            } finally {  
                System.out.println(this.id + " arrived !");  
                end.countDown();  
            }  
        }  
      
    }  

CountDownLatch强调的是一个线程（或多个）需要等待另外的n个线程干完某件事情之后才能继续执行。

2. 继续，还是这五个人（这五个人真无聊…），这次没裁判。规定五个人只要都跑到终点了，大家可以喝啤酒。但是，只要有一个人没到终点，就不能喝。 这里也没有要求大家要同时起跑(当然也可以，加latch)。

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
 
public class Beer {
 
	public static void main(String[] args) {
		final int count = 5;
		final CyclicBarrier barrier = new CyclicBarrier(count, new Runnable() {
			@Override
			public void run() {
				System.out.println("drink beer!");
			}
		});
 
		// they do not have to start at the same time...
		for (int i = 0; i < count; i++) {
			new Thread(new Worker(i, barrier)).start();
		}
	}
 
}
 
class Worker implements Runnable {
	final int id;
	final CyclicBarrier barrier;
 
	public Worker(final int id, final CyclicBarrier barrier) {
		this.id = id;
		this.barrier = barrier;
	}
 
	@Override
	public void run() {
		try {
			System.out.println(this.id + "starts to run !");
			Thread.sleep((long) (Math.random() * 10000));
			System.out.println(this.id + "arrived !");
			this.barrier.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (BrokenBarrierException e) {
			e.printStackTrace();
		}
	}
}

CyclicBarrier强调的是n个线程，大家相互等待，只要有一个没完成，所有人都得等着。