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

来源：互联网发布：手机兼职打字员软件编辑：程序博客网时间：2024/05/16 06:52

1　等待多线程完成的CountDownLatch

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

代码示例如下：

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

2　同步屏障CyclicBarrier

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

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

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

示例：

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，方便处理更复杂的业务场景

示例：

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可以用于多线程计算数据，最后合并计算结果的场景，示例：

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()方法用来了解阻塞的线程是否被中断。

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个线程同时获取数据库连接保存数据，否则会报错无法获取数据库连接。

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方法，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方。

代码示例：

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

阅读全文

1 0

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

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