第8章 Java中的并发工具类（CountDownLatch CyclicBarrier Semaphore Exchanger）

1　等待多线程完成的CountDownLatch

CountDownLatch允许一个或多个线程等待其他线程完成操作。

代码示例如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

package  com.tlk.chapter8;   import  java.util.concurrent.CountDownLatch;   public  class  CountDownLatchTest {      static  CountDownLatch c =  new  CountDownLatch( 2 );        public  static  void  main(String[] args)  throws  InterruptedException {          new  Thread( new  Runnable() {              @Override              public  void  run() {                  System.out.println( 1 );                  c.countDown();                  System.out.println( 2 );                  c.countDown();              }          }).start();          c.await();          System.out.println( "3" );      } }

类似于thread.join() 线程执行完毕后，才继续执行主线程。同join，如果我们不想一直让主线程等待，可以设置超时时间await（long time，TimeUnit unit）

使用场景：

1. 实现最大的并行性：有时我们想同时启动多个线程，实现最大程度的并行性。例如，我们想测试一个单例类。如果我们创建一个初始计数为1的CountDownLatch，并让所有线程都在这个锁上等待，那么我们可以很轻松地完成测试。我们只需调用 一次countDown()方法就可以让所有的等待线程同时恢复执行。
2. 开始执行前等待n个线程完成各自任务：例如应用程序启动类要确保在处理用户请求前，所有N个外部系统已经启动和运行了。
3. 死锁检测：一个非常方便的使用场景是，你可以使用n个线程访问共享资源，在每次测试阶段的线程数目是不同的，并尝试产生死锁。

2　同步屏障CyclicBarrier

CyclicBarrier的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组 线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门， 所有被屏障拦截的线程才会继续运行。

我自己的理解CyclicBarrier非常类似集齐七颗龙珠召唤神龙，尤其CyclicBarrier（int parties，Runnable barrierAction），barrierAction就是那个神龙

 CyclicBarrier默认的构造方法是CyclicBarrier（int parties），其参数表示屏障拦截的线程数量， 每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞

示例：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

package  com.tlk.chapter8;   import  java.util.concurrent.CyclicBarrier;   public  class  CyclicBarrierTest {      // 如果把new CyclicBarrier(2)修改成newCyclicBarrier(3)，则主线程和子线程会永远等待，因为没有第三个线程执行await方法，      // 即没有第三个线程到达屏障，所以之前到达屏障的两个线程都不会继续执行。      static  CyclicBarrier c =  new  CyclicBarrier( 2 );        // 因为主线程和子线程的调度是由CPU决定的，两个线程都有可能先执行      public  static  void  main(String[] args) {          new  Thread( new  Runnable() {              @Override              public  void  run() {                  try  {                      c.await();                  }  catch  (Exception e) {                    }                  System.out.println( 1 );                }          }).start();            try  {              c.await();          }  catch  (Exception e) {          }          System.out.println( 2 );      } }

CyclicBarrier还提供一个更高级的构造函数CyclicBarrier（int parties，Runnable barrier- Action），用于在线程到达屏障时，优先执行barrierAction，方便处理更复杂的业务场景

示例：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

package  com.tlk.chapter8;   import  java.util.concurrent.CyclicBarrier;   public  class  CyclicBarrierTest2 {      //构造器CyclicBarrier(int parties, Runnable barrierAction)，barrierAction有限执行      static  CyclicBarrier c =  new  CyclicBarrier( 2 ,  new  A());        public  static  void  main(String[] args) {          new  Thread( new  Runnable() {              @Override              public  void  run() {                  try  {                      c.await();                  }  catch  (Exception e) {                  }                  System.out.println( 1 );              }          }).start();          try  {              c.await();          }  catch  (Exception e) {          }          System.out.println( 2 );      }        static  class  A  implements  Runnable {          @Override          public  void  run() {              System.out.println( 3 );          }      } }

CyclicBarrier的应用场景

    CyclicBarrier可以用于多线程计算数据，最后合并计算结果的场景，示例：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

package  com.tlk.chapter8;   import  java.util.Map.Entry; import  java.util.concurrent.BrokenBarrierException; import  java.util.concurrent.ConcurrentHashMap; import  java.util.concurrent.CyclicBarrier; import  java.util.concurrent.Executor; import  java.util.concurrent.Executors;   /**   * 银行流水处理服务类    * 用一个Excel保存了 用户所有银行流水，每个Sheet保存一个账户近一年的每笔银行流水，现在需要统计用户的日均银行   * 流水，先用多线程处理每个sheet里的银行流水，都执行完之后，得到每个sheet的日均银行流水，最   * 后，再用barrierAction用这些线程的计算结果，计算出整个Excel的日均银行流水   */ public  class  BankWaterService  implements  Runnable {      /**       * 创建4个屏障，处理完之后执行当前类的run方法       */      private  CyclicBarrier c =  new  CyclicBarrier( 4 ,  this );      /**       * 假设只有4个sheet，所以只启动4个线程       */      private  Executor executor = Executors.newFixedThreadPool( 4 );      /**       * 保存每个sheet计算出的银流结果       */      private  ConcurrentHashMap<String, Integer> sheetBankWaterCount =  new  ConcurrentHashMap<String, Integer>();        private  void  count() {          for  ( int  i =  0 ; i <  4 ; i++) {              executor.execute( new  Runnable() {                  @Override                  public  void  run() {                      // 计算当前sheet的银流数据，计算代码省略                      sheetBankWaterCount.put(Thread.currentThread().getName(),  1 );                      // 银流计算完成，插入一个屏障                      try  {                          c.await();                      }  catch  (InterruptedException | BrokenBarrierException e) {                          e.printStackTrace();                      }                  }              });          }      }        @Override      public  void  run() {          int  result =  0 ;          // 汇总每个sheet计算出的结果          for  (Entry<String, Integer> sheet : sheetBankWaterCount.entrySet()) {              result += sheet.getValue();          }          // 将结果输出          sheetBankWaterCount.put( "result" , result);          System.out.println(result);      }        public  static  void  main(String[] args) {          BankWaterService bankWaterCount =  new  BankWaterService();          bankWaterCount.count();      } }

注意：以上代码用的是Executor而不是ExecutorService，最后没有shutdown();所以打印出结果后，main方法也会继续执行

CyclicBarrier和CountDownLatch的区别

CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset()方法重置。所 以CyclicBarrier能处理更为复杂的业务场景。例如，如果计算发生错误，可以重置计数器，并让线程 重新执行一次。

CyclicBarrier还提供其他有用的方法，比如getNumberWaiting方法可以获得Cyclic-Barrier阻塞的 线程数量。isBroken()方法用来了解阻塞的线程是否被中断。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

package  com.tlk.chapter8;   import  java.util.concurrent.BrokenBarrierException; import  java.util.concurrent.CyclicBarrier;   public  class  CyclicBarrierTest3 {      static  CyclicBarrier c =  new  CyclicBarrier( 3 );        public  static  void  main(String[] args) {          Thread thread =  new  Thread( new  Runnable() {                @Override              public  void  run() {                  try  {                      c.await();                  }  catch  (InterruptedException | BrokenBarrierException e) {                      // e.printStackTrace();                  }              }          });          thread.start();          thread.interrupt();            try  {              c.await();          }  catch  (InterruptedException | BrokenBarrierException e) {              // isBroken()方法用来了解阻塞的线程是否被中断              System.out.println(c.isBroken());          }        }   }

3　控制并发线程数的Semaphore

Semaphore（信号量）是用来控制同时访问特定资源的线程数量，它通过协调各个线程，以保证 合理的使用公共资源。

我感觉用驾考科目一考试来形容比较合适。北京玉马考场科目一考试只有100台机器，进入考场的只能有100个考生，当有考生考试结束时，排队的人才能进入考试。这里的考生就是线程，进入考场考试表示线程在执行，离开考场表示线程执行完成，考场有100人在考试，就表示线程被阻塞，不能被执行。

Semaphore应用场景

流量控制

特别是公用资源有限的应用场景，比如数据库连接。假如有一 个需求，要读取几万个文件的数据，因为都是IO密集型任务，我们可以启动几十个线程并发地读 取，但是如果读到内存后，还需要存储到数据库中，而数据库的连接数只有5个，这时我们必须控 制只有5个线程同时获取数据库连接保存数据，否则会报错无法获取数据库连接。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

package  com.tlk.chapter8;   import  java.util.concurrent.ExecutorService; import  java.util.concurrent.Executors; import  java.util.concurrent.Semaphore;   public  class  SemaphoreTest {      private  static  final  int  THREAD_COUNT =  30 ;      private  static  ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_COUNT);      private  static  Semaphore s =  new  Semaphore( 5 );        public  static  void  main(String[] args) {          for  ( int  i =  0 ; i < THREAD_COUNT; i++) {              threadPool.execute( new  Runnable() {                  @Override                  public  void  run() {                      try  {                          s.acquire();                          System.out.println( "save data" );                          //如果注释掉s.release(),打印5条save data后就会阻塞                          s.release();                      }  catch  (InterruptedException e) {                      }                  }              });          }          threadPool.shutdown();      } }

其他方法

Semaphore还提供一些其他方法，具体如下。

·int availablePermits()：返回此信号量中当前可用的许可证数。

·int getQueueLength()：返回正在等待获取许可证的线程数。

·boolean hasQueuedThreads()：是否有线程正在等待获取许可证。

·void reducePermits（int reduction）：减少reduction个许可证，是个protected方法。

·Collection getQueuedThreads()：返回所有等待获取许可证的线程集合，是个protected方法。

4　线程间交换数据的Exchanger

Exchanger（交换者）是一个用于线程间协作的工具类。Exchanger用于进行线程间的数据交换。 它提供一个同步点，在这个同步点，两个线程可以交换彼此的数据。这两个线程通过exchange方法 交换数据，如果第一个线程先执行exchange()方法，它会一直等待第二个线程也执行exchange方法， 当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方。

代码示例：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

package  com.tlk.chapter8;   import  java.util.concurrent.Exchanger; import  java.util.concurrent.ExecutorService; import  java.util.concurrent.Executors;   public  class  ExchangerTest {      private  static  final  Exchanger<String> exgr =  new  Exchanger<String>();      private  static  ExecutorService threadPool = Executors.newFixedThreadPool( 2 );        public  static  void  main(String[] args) {          threadPool.execute( new  Runnable() {              @Override              public  void  run() {                  try  {                      String A =  "银行流水A" ; // A录入银行流水数据                      exgr.exchange(A);                  }  catch  (InterruptedException e) {                  }              }          });          threadPool.execute( new  Runnable() {              @Override              public  void  run() {                  try  {                      String B =  "银行流水C" ; // B录入银行流水数据                      String C = exgr.exchange( "B" );                      System.out.println(C);                      System.out.println( "A和B数据是否一致："  + C.equals(B) +  "，A录入的是："  + C +  "，B录入是："  + B);                  }  catch  (InterruptedException e) {                  }              }          });          threadPool.shutdown();      } }

对于Exchanger理解不是太深，没怎么想到项目中真正要利用的场景，欢迎留言解答，谢谢！