本文主要是介绍第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" ); } } |
使用场景：
- 实现最大的并行性：有时我们想同时启动多个线程，实现最大程度的并行性。例如，我们想测试一个单例类。如果我们创建一个初始计数为1的CountDownLatch，并让所有线程都在这个锁上等待，那么我们可以很轻松地完成测试。我们只需调用 一次countDown()方法就可以让所有的等待线程同时恢复执行。
- 开始执行前等待n个线程完成各自任务：例如应用程序启动类要确保在处理用户请求前，所有N个外部系统已经启动和运行了。
- 死锁检测：一个非常方便的使用场景是，你可以使用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理解不是太深，没怎么想到项目中真正要利用的场景，欢迎留言解答，谢谢！
这篇关于第8章 Java中的并发工具类（CountDownLatch CyclicBarrier Semaphore Exchanger）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
