Semaphore，CountDownLatch，CyclicBarrier

1、atomic包的原理及分析

概论：

• CountDownLatch是一个计数器闭锁，主要的功能就是通过await()方法来阻塞住当前线程，然后等待计数器减少到0了，再唤起这些线程继续执行。 这个类里主要有两个方法，一个是向下减计数器的方法countdown()；
• Semaphore与CountDownLatch相似，不同的地方在于Semaphore的值被获取到后是可以释放的，并不像CountDownLatch那样一直减到底。它也被更多地用来限制流量，类似阀门的 功能。如果限定某些资源最多有N个线程可以访问，那么超过N个主不允许再有线程来访问，同时当现有线程结束后，就会释放，然后允许新的线程进来。有点类似于锁的lock与 unlock过程。相对来说他也有两个主要的方法：
  用于获取权限的acquire()，其底层实现与CountDownLatch.countdown()类似；用于释放权限的release()，其底层实现与acquire()是一个互逆的过程。

• CyclicBarrier是用来一个关卡来阻挡住所有线程，等所有线程全部执行到关卡处时，再统一执行下一步操作，它里面最重要的方法是await()方法

  1. Semaphore
• 一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动；

• Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。例如，下面的类使用信号量控制对内容池的访问：

       class Pool {
         private static final int MAX_AVAILABLE = 100;
         private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);
  
         public Object getItem() throws InterruptedException {
           available.acquire();
           return getNextAvailableItem();
         }
  
         public void putItem(Object x) {
           if (markAsUnused(x))
             available.release();
         }
  
         // Not a particularly efficient data structure; just for demo
  
         protected Object[] items = ... whatever kinds of items being managed
         protected boolean[] used = new boolean[MAX_AVAILABLE];
  
         protected synchronized Object getNextAvailableItem() {
           for (int i = 0; i < MAX_AVAILABLE; ++i) {
             if (!used[i]) {
                used[i] = true;
                return items[i];
             }
           }
           return null; // not reached
         }
  
         protected synchronized boolean markAsUnused(Object item) {
           for (int i = 0; i < MAX_AVAILABLE; ++i) {
             if (item == items[i]) {
                if (used[i]) {
                  used[i] = false;
                  return true;
                } else
                  return false;
             }
           }
           return false;
         }
  
       }
  

• 获得一项前，每个线程必须从信号量获取许可，从而保证可以使用该项。该线程结束后，将项返回到池中并将许可返回到该信号量，从而允许其他线程获取该项。注意，调用 acquire() 时无法保持同步锁，因为这会阻止将项返回到池中。信号量封装所需的同步，以限制对池的访问，这同维持该池本身一致性所需的同步是分开的。
• 将信号量初始化为 1，使得它在使用时最多只有一个可用的许可，从而可用作一个相互排斥的锁。这通常也称为二进制信号量，因为它只能有两种状态：一个可用的许可，或零个可用的许可。按此方式使用时，二进制信号量具有某种属性（与很多 Lock 实现不同），即可以由线程释放“锁”，而不是由所有者（因为信号量没有所有权的概念）。在某些专门的上下文（如死锁恢复）中这会很有用。
• 此类的构造方法可选地接受一个公平 参数。当设置为 false 时，此类不对线程获取许可的顺序做任何保证。特别地，闯入 是允许的，也就是说可以在已经等待的线程前为调用 acquire() 的线程分配一个许可，从逻辑上说，就是新线程将自己置于等待线程队列的头部。当公平设置为 true 时，信号量保证对于任何调用获取方法的线程而言，都按照处理它们调用这些方法的顺序（即先进先出；FIFO）来选择线程、获得许可。注意，FIFO 排序必然应用到这些方法内的指定内部执行点。所以，可能某个线程先于另一个线程调用了 acquire，但是却在该线程之后到达排序点，并且从方法返回时也类似。还要注意，非同步的 tryAcquire 方法不使用公平设置，而是使用任意可用的许可。

• 通常，应该将用于控制资源访问的信号量初始化为公平的，以确保所有线程都可访问资源。为其他的种类的同步控制使用信号量时，非公平排序的吞吐量优势通常要比公平考虑更为重要。

  1. CountDownLatch
• 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
• 用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier。
• CountDownLatch 是一个通用同步工具，它有很多用途。将计数 1 初始化的 CountDownLatch 用作一个简单的开/关锁存器，或入口：在通过调用 countDown() 的线程打开入口前，所有调用 await 的线程都一直在入口处等待。用 N 初始化的 CountDownLatch 可以使一个线程在 N 个线程完成某项操作之前一直等待，或者使其在某项操作完成 N 次之前一直等待。

• CountDownLatch 的一个有用特性是，它不要求调用 countDown 方法的线程等到计数到达零时才继续，而在所有线程都能通过之前，它只是阻止任何线程继续通过一个 await。

• 示例用法： 下面给出了两个类，其中一组 worker 线程使用了两个倒计数锁存器：
  第一个类是一个启动信号，在 driver 为继续执行 worker 做好准备之前，它会阻止所有的 worker 继续执行。
  第二个类是一个完成信号，它允许 driver 在完成所有 worker 之前一直等待。

      class Driver { // ...
         void main() throws InterruptedException {
           CountDownLatch startSignal = new CountDownLatch(1);
           CountDownLatch doneSignal = new CountDownLatch(N);
  
           for (int i = 0; i < N; ++i) // create and start threads
             new Thread(new Worker(startSignal, doneSignal)).start();
  
           doSomethingElse();            // don't let run yet
           startSignal.countDown();      // let all threads proceed
           doSomethingElse();
           doneSignal.await();           // wait for all to finish
         }
       }
  
       class Worker implements Runnable {
         private final CountDownLatch startSignal;
         private final CountDownLatch doneSignal;
         Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
            this.startSignal = startSignal;
            this.doneSignal = doneSignal;
         }
         public void run() {
            try {
              startSignal.await();
              doWork();
              doneSignal.countDown();
      } catch (InterruptedException ex) {} // return;
         }
  
         void doWork() { ... }
       }
  

  1. CyclicBarrier
     
     • 一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。
• CyclicBarrier 支持一个可选的 Runnable 命令，在一组线程中的最后一个线程到达之后（但在释放所有线程之前），该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态，此屏障操作 很有用。

• 示例用法：下面是一个在并行分解设计中使用 barrier 的例子：

       class Solver {
         final int N;
         final float[][] data;
         final CyclicBarrier barrier;
  
         class Worker implements Runnable {
           int myRow;
           Worker(int row) { myRow = row; }
           public void run() {
             while (!done()) {
               processRow(myRow);
  
               try {
                 barrier.await(); 
               } catch (InterruptedException ex) { 
      return; 
               } catch (BrokenBarrierException ex) { 
      return; 
               }
             }
           }
         }
  
         public Solver(float[][] matrix) {
           data = matrix;
           N = matrix.length;
           barrier = new CyclicBarrier(N, 
                                       new Runnable() {
                                         public void run() { 
                                           mergeRows(...); 
                                         }
                                       });
           for (int i = 0; i < N; ++i) 
             new Thread(new Worker(i)).start();
  
           waitUntilDone();
         }
       }
  

  在这个例子中，每个 worker 线程处理矩阵的一行，在处理完所有的行之前，该线程将一直在屏障处等待。处理完所有的行之后，将执行所提供的 Runnable 屏障操作，并合并这些行。如果合并者确定已经找到了一个解决方案，那么 done() 将返回 true，所有的 worker 线程都将终止。

• 如果屏障操作在执行时不依赖于正挂起的线程，则线程组中的任何线程在获得释放时都能执行该操作。为方便此操作，每次调用 await() 都将返回能到达屏障处的线程的索引。然后，您可以选择哪个线程应该执行屏障操作，例如：
  if (barrier.await() == 0) {
  // log the completion of this iteration
  }
  对于失败的同步尝试，CyclicBarrier 使用了一种要么全部要么全不 (all-or-none) 的破坏模式：如果因为中断、失败或者超时等原因，导致线程过早地离开了屏障点，那么在该屏障点等待的其他所有线程也将通过 BrokenBarrierException（如果它们几乎同时被中断，则用 InterruptedException）以反常的方式离开。

• 内存一致性效果：线程中调用 await() 之前的操作 happen-before 那些是屏障操作的一部份的操作，后者依次 happen-before 紧跟在从另一个线程中对应 await() 成功返回的操作。