第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理解不是太深，没怎么想到项目中真正要利用的场景，欢迎留言解答，谢谢！