线程知识学习六——并发（辅助类）

继其几篇博客线程的并发知识的了解，我们使用了synchronized和lock，我们这篇博客说实现线程并发的一些辅助类。

辅助类概览

都有哪些辅助类呢？我们看下图



图中有五个辅助类，分别是：信号量，countDownLatch，CyclicBarrier、Phaser、Exchanger。

五个类各自有不同的特长。

CountDownLatch

CountDownLatch：在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。用给定的计数初始化CountDownLatch。由于调用了countDown()方法，所以在当前计数到达零之前，await方法会一直受阻塞。之后，会释放所有等待的线程，await的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用辅助类：CyclicBarrier。

主要方法如下：

public CountDownLatch(int count);

构造方法参数指定了计数的次数。

public void countDown();

countDown方法，当前线程调用此方法，则计数减一。

public void await() throws InterruptedException

awaint方法，调用此方法会一直阻塞当前线程，直到计时器的值为0。

示例代码如下：

import java.util.concurrent.CountDownLatch;
class CountDownLatchDemo {
/**
* CountDownLatch：闭锁
* 在完成一组正在其他线程中执行的操作之前，它约束一个或多个线程一直等待。
* 可用于：子任务执行完成后再进行另一个操作。
*/
static void test(int threadTaskNum) {
final CountDownLatch answers = new CountDownLatch(threadTaskNum);//同步计数器
for (int i = 0; i < threadTaskNum; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("线程" + Thread.currentThread().getName() + " 开始处理任务 ...");
Thread.sleep((long) (Math.random() * 5000));
System.out.println("线程" + Thread.currentThread().getName() + " 处理完毕，汇报结果！");
answers.countDown();
} catch (Exception e) {}
}
}).start();
}
try {
answers.await();// 在所有子线程结束前保持阻塞
} catch (InterruptedException e) {}
System.out.println("线程" + Thread.currentThread().getName() + "已收到所有汇报结果");
}
}
public class Test {
public static void main(String[] args) {
CountDownLatchDemo.test(3);
}
}

CyclicBarrier

CyclicBarrier是一个同步的辅助类，它允许一组线程互相等待，直到到达某个公告屏障点。在设计一组固定大小的线程的程序中，这些线程必须不时的相互等待，此时它很有用，因为该屏障在释放等待线程后可以重用，所以称它为循环的屏障。

下面看看对应的方法。

public CyclicBarrier(int parties, Runnable barrierAction)

创建一个新的CycleBarrier,它将在给定数量的参与者（线程）处于等待状态时候启动，并在启动barrier时执行给定的屏障操作，该操作由最后一个今日的屏障的线程执行。参数barrierAction是在启动屏障的时候执行命令，如果不执行任何操作则该参数是null。

public int await()

在所有参与者都已经在此barrier上调用 await方法之前，将一直等待。如果当前线程部署将要到达的最后一个线程将禁用它。

reset

将屏障重置为其初始化状态，如果所有参与者目前都在屏障处等待，则它们将返回，而且会抛出一个异常。

getNumberWaiting

返回当前在屏障处等待的参与者数目。

代码示例：

import java.util.concurrent.CyclicBarrier;
class CyclicBarrierDemo {
/**
* CyclicBarrier：屏障
* 它约束一组线程必需达到某时刻，再向下执行，在没有完全达到之前保持等待
* 比如：开会，必须要等所有人都到大厅后，会议才能开始。
*/
static void test(int threadNum) {
//        CyclicBarrier cyclicBarrier  = new CyclicBarrier(3);
// 构造方法可支持一个Runnable，用于在所有线程都达到后首先执行。
final CyclicBarrier cyclicBarrier  = new CyclicBarrier(3, new Runnable() {
@Override
public void run() {
System.out.println("都准备好了！");
}
});
for (int i = 0; i < threadNum; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("线程" + Thread.currentThread().getName() + " 已经准备好.");
cyclicBarrier.await();
Thread.sleep((long) (Math.random() * 2000));
System.out.println("线程" + Thread.currentThread().getName() + " 处理完毕，汇报结果！");
} catch (Exception e) {}
}
}).start();
}
}
}
public class Test {
public static void main(String[] args) {
CyclicBarrierDemo.test(3);
}
}

下篇博客继续信号量和Phaser,exchanger。