3.1 闭锁（Latch）

闭锁（Latch）：一种同步方法，可以延迟线程的进度直到线程到达某个终点状态。通俗的讲就是，一个闭锁相当于一扇大门，在大门打开之前所有线程都被阻断，一旦大门打开所有线程都将通过，但是一旦大门打开，所有线程都通过了，那么这个闭锁的状态就失效了，门的状态也就不能变了，只能是打开状态。也就是说闭锁的状态是一次性的，它确保在闭锁打开之前所有特定的活动都需要在闭锁打开之后才能完成。

CountDownLatch是JDK 5+里面闭锁的一个实现，允许一个或者多个线程等待某个事件的发生。CountDownLatch有一个正数计数器，countDown方法对计数器做减操作，await方法等待计数器达到0。所有await的线程都会阻塞直到计数器为0或者等待线程中断或者超时。

CountDownLatch的API如下。

• public void await() throws InterruptedException
• public boolean await(long timeout, TimeUnit unit) throws InterruptedException
• public void countDown()
• public long getCount()

其中getCount()描述的是当前计数，通常用于调试目的。

清单4闭锁的两种常见的用法：

import java.util.concurrent.CountDownLatch;public class PerformanceTestTool {    public long timecost(final int times, final Runnable task) throws InterruptedException {        if (times <= 0) throw new IllegalArgumentException();        final CountDownLatch startLatch = new CountDownLatch(1);        final CountDownLatch overLatch = new CountDownLatch(times);        for (int i = 0; i < times; i++) {            new Thread(new Runnable() {                public void run() {                    try {                        startLatch.await();                        //                        task.run();                    } catch (InterruptedException ex) {                        Thread.currentThread().interrupt();                    } finally {                        overLatch.countDown();                    }                }            }).start();        }        //        long start = System.nanoTime();        startLatch.countDown();        overLatch.await();        return System.nanoTime() - start;    }}

在上面的例子中使用了两个闭锁，第一个闭锁确保在所有线程开始执行任务前，所有准备工作都已经完成，一旦准备工作完成了就调用startLatch.countDown()打开闭锁，所有线程开始执行。第二个闭锁在于确保所有任务执行完成后主线程才能继续进行，这样保证了主线程等待所有任务线程执行完成后才能得到需要的结果。在第二个闭锁当中，初始化了一个N次的计数器，每个任务执行完成后都会将计数器减一，所有任务完成后计数器就变为了0，这样主线程闭锁overLatch拿到此信号后就可以继续往下执行了。

根据前面的happend-before法则可以知道闭锁有以下特性：

内存一致性效果：线程中调用 countDown() 之前的操作 happen-before 紧跟在从另一个线程中对应 await() 成功返回的操作。

在上面的例子中第二个闭锁相当于把一个任务拆分成N份，每一份独立完成任务，主线程等待所有任务完成后才能继续执行。这个特性在后面的线程池框架中会用到，其实FutureTask就可以看成一个闭锁。后面的章节还会具体分析FutureTask的。

同样基于探索精神，仍然需要“窥探”下CountDownLatch里面到底是如何实现await*和countDown的。

首先，研究下await()方法。内部直接调用了AQS的acquireSharedInterruptibly(1)。

public final void acquireSharedInterruptibly(int arg) throws InterruptedException {    if (Thread.interrupted())        throw new InterruptedException();    if (tryAcquireShared(arg) < 0)        doAcquireSharedInterruptibly(arg);}

前面一直提到的都是独占锁（排它锁、互斥锁），现在就用到了另外一种锁，共享锁。

所谓共享锁是说所有共享锁的线程共享同一个资源，一旦任意一个线程拿到共享资源，那么所有线程就都拥有的同一份资源。也就是通常情况下共享锁只是一个标志，所有线程都等待这个标识是否满足，一旦满足所有线程都被激活（相当于所有线程都拿到锁一样）。这里的闭锁CountDownLatch就是基于共享锁的实现。

四、CyclicBarrier 

一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。
在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。

CyclicBarrier 支持一个可选的 Runnable 命令，在一组线程中的最后一个线程到达之后（但在释放所有线程之前），
该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态，此屏障操作 很有用。

清单5：下面是一个在并行分解设计中使用 barrier 的例子，很经典的旅行团例子：

import java.text.SimpleDateFormat;  import java.util.Date;  import java.util.concurrent.BrokenBarrierException;  import java.util.concurrent.CyclicBarrier;  import java.util.concurrent.ExecutorService;  import java.util.concurrent.Executors;  public class TestCyclicBarrier {    // 徒步需要的时间: Shenzhen, Guangzhou, Shaoguan, Changsha, Wuhan    private static int[] timeWalk = { 5, 8, 15, 15, 10 };    // 自驾游    private static int[] timeSelf = { 1, 3, 4, 4, 5 };    // 旅游大巴    private static int[] timeBus = { 2, 4, 6, 6, 7 };        static String now() {       SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");       return sdf.format(new Date()) + ": ";    }    static class Tour implements Runnable {       private int[] times;       private CyclicBarrier barrier;       private String tourName;       public Tour(CyclicBarrier barrier, String tourName, int[] times) {         this.times = times;         this.tourName = tourName;         this.barrier = barrier;       }       public void run() {         try {           Thread.sleep(times[0] * 1000);           System.out.println(now() + tourName + " Reached Shenzhen");           barrier.await();           Thread.sleep(times[1] * 1000);           System.out.println(now() + tourName + " Reached Guangzhou");           barrier.await();           Thread.sleep(times[2] * 1000);           System.out.println(now() + tourName + " Reached Shaoguan");           barrier.await();           Thread.sleep(times[3] * 1000);           System.out.println(now() + tourName + " Reached Changsha");           barrier.await();           Thread.sleep(times[4] * 1000);           System.out.println(now() + tourName + " Reached Wuhan");           barrier.await();         } catch (InterruptedException e) {         } catch (BrokenBarrierException e) {         }       }    }    public static void main(String[] args) {       // 三个旅行团       CyclicBarrier barrier = new CyclicBarrier(3);       ExecutorService exec = Executors.newFixedThreadPool(3);       exec.submit(new Tour(barrier, "WalkTour", timeWalk));       exec.submit(new Tour(barrier, "SelfTour", timeSelf));  //当我们把下面的这段代码注释后，会发现，程序阻塞了，无法继续运行下去。       exec.submit(new Tour(barrier, "BusTour", timeBus));       exec.shutdown();    }  }   

CyclicBarrier最重要的属性就是参与者个数，另外最要方法是await()。当所有线程都调用了await()后，就表示这些线程都可以继续执行，否则就会等待。

4.1 CyclicBarrier的特点

CyclicBarrier有以下几个特点：

await()方法将挂起线程，直到同组的其它线程执行完毕才能继续
await()方法返回线程执行完毕的索引，注意，索引时从任务数-1开始的，也就是第一个执行完成的任务索引为parties-1,最后一个为0，这个parties为总任务数
CyclicBarrier 是可循环的，显然名称说明了这点。

另外CyclicBarrier除了以上特点外，还有以下几个特点：

如果屏障操作不依赖于挂起的线程，那么任何线程都可以执行屏障操作。

CyclicBarrier 的构造函数允许携带一个任务，这个任务将在0%屏障点执行，它将在await()==0后执行。
CyclicBarrier 如果在await时因为中断、失败、超时等原因提前离开了屏障点，那么任务组中的其他任务将立即被中断，以InterruptedException异常离开线程。
所有await()之前的操作都将在屏障点之前运行，也就是CyclicBarrier 的内存一致性效果（happe）
 

CyclicBarrier 的所有API如下：

public CyclicBarrier(int parties) 创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，但它不会在启动 barrier 时执行预定义的操作。
public CyclicBarrier(int parties, Runnable barrierAction) 创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，并在启动 barrier 时执行给定的屏障操作，该操作由最后一个进入 barrier 的线程执行。
public int await() throws InterruptedException, BrokenBarrierException 在所有参与者都已经在此 barrier 上调用 await 方法之前，将一直等待。
public int await(long timeout,TimeUnit unit) throws InterruptedException, BrokenBarrierException,TimeoutException 在所有参与者都已经在此屏障上调用 await 方法之前将一直等待,或者超出了指定的等待时间。
public int getNumberWaiting() 返回当前在屏障处等待的参与者数目。此方法主要用于调试和断言。
public int getParties() 返回要求启动此 barrier 的参与者数目。
public boolean isBroken() 查询此屏障是否处于损坏状态。
public void reset() 将屏障重置为其初始状态。

五、Exchanger