java 多线程同步辅助类(CountDownLatch、CyclicBarrier、Semaphore、Exchanger)
CountDownLatch示例：
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);
}
}输出：
线程Thread-0 开始处理任务 ... 线程Thread-1 开始处理任务 ... 线程Thread-2 开始处理任务 ... 线程Thread-0 处理完毕，汇报结果！ 线程Thread-1 处理完毕，汇报结果！ 线程Thread-2 处理完毕，汇报结果！ 线程main已收到所有汇报结果
可以看到主线程一直等到所有子线程执行完毕后进行下一步工作。
CyclicBarrier示例：
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);
}
}输出：
线程Thread-0 已经准备好. 线程Thread-1 已经准备好. 线程Thread-2 已经准备好. 都准备好了！ 线程Thread-1 处理完毕，汇报结果！ 线程Thread-0 处理完毕，汇报结果！ 线程Thread-2 处理完毕，汇报结果！可以看到三个线程互相等待，知道所有线程都准备好以后同时开始向下执行。
Semaphore示例：
import java.util.concurrent.Semaphore;
class SemaphoreDemo {
/**
* Semaphore：信号量
* 当前在多线程环境下被扩放使用，操作系统的信号量是个很重要的概念，在进程控制方面都有应用。
* Java 并发库 的Semaphore 可以很轻松完成信号量控制，
* Semaphore可以控制某个资源可被同时访问的个数，
* 通过 acquire() 获取一个许可，如果没有就等待，
* 通过 release() 释放一个许可。
* 比如在Windows下可以设置共享文件的最大客户端访问个数。
*/
static void test(int threadNum) {
// Semaphore semaphore = new Semaphore(threadNum, true);// 是否公平
final Semaphore semaphore = new Semaphore(3);//最多同时允许 3 个线程并发访问
for (int i = 0; i < threadNum; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("线程" + Thread.currentThread().getName() + " 想要处理，剩余凭证：" + semaphore.availablePermits());
semaphore.acquire();
Thread.sleep((long) (Math.random() * 2000));
System.out.println("线程" + Thread.currentThread().getName() + " 处理完毕，归还凭证！");
// 如果注释下面这行，表示不释放凭证，那么后续线程将永远阻塞在semaphore.acquire();上
semaphore.release();// 用完后要释放，以给其它线程使用
} catch (Exception e) {}
}
}).start();
}
}
}
public class Test {
public static void main(String[] args) {
SemaphoreDemo.test(5);
}
}输出：
线程Thread-0 想要处理，剩余凭证：3 线程Thread-1 想要处理，剩余凭证：2 线程Thread-2 想要处理，剩余凭证：1 线程Thread-3 想要处理，剩余凭证：0 线程Thread-4 想要处理，剩余凭证：0 线程Thread-0 处理完毕，归还凭证！ 线程Thread-1 处理完毕，归还凭证！ 线程Thread-3 处理完毕，归还凭证！ 线程Thread-2 处理完毕，归还凭证！ 线程Thread-4 处理完毕，归还凭证！因为凭证只有三张，3和4两个线程在一开始拿不到凭证（剩余凭证为0）会阻塞直到有线程归还后才能拿到，从而控制了并发访问的线程数量。
Exchanger用于实现两个线程数据交换，当两个线程达到共同的同步点（都在进行exchanger.exchange的时刻）时，发生数据交换，即线程1的数据传递给线程2，线程2的数据传递给线程1，如果一方没有达到同步点（没有执行到exchanger.exchange），则另一方处于等待状态。
使用Exchanger，可以很方便地实现经典的“生产-消费”模式，一个生产线程，一个消费线程，各自持有一个数据集合，生产线程将准备好的数据装入自己的数据集合，消费线程消费自己数据集合中的数据，生产线程准备好数据后（已经装入自己的数据集合）进行exchanger.exchange，此时如果消费线程没有在等待消费数据则生产线程等待，如果消费线程正在等待数据，则立即发生双方数据集合的交换。另一个场景，如果消费过快，消费线程进行exchanger.exchange（即请求消费数据），此时如果生产线程没有进行exchanger.exchange（即数据没有生产就绪）则消费线程也会等待，直到生产线程和消费线程读准备好后进行数据的“转移“（即双方数据集合的交换），由生产者将装好数据的数据集合转移到消费者，由消费者将消费完为空的数据集合转移到生产者。
生活中也有很多这样的例子，如自来水送水，送水员和家庭用户在一个地点见面，一般是自家门口（即达到共同同步点），送水员将装满水的桶交给家庭用户，家庭用户将用完水的空桶交给送水员，这样就是交换水桶（即发生数据交换），如果送水员先到门口，家庭用户正在忙别的没有开门，则送水员会等待开门，反之，如果家庭用户到了门口发现送水员还没到，那么也只能等送水员到来，否则无法完成换桶（即没有达到同步点都需要等待对方，当然可以设置超时时间）
Exchanger示例：
import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.Exchanger;
public class Test {
public static void main(String[] args) {
new FillAndEmpty().start();
}
}
class FillAndEmpty {
Exchanger<Queue> exchanger = new Exchanger<Queue>();
void start() {
new Thread(new FillingLoop(), "FillingLoop").start();
new Thread(new EmptyingLoop(), "EmptyingLoop").start();
}
private void addToQueue(Queue queue) {
try {Thread.sleep(1000);} catch (InterruptedException e) {}
for (int i = 0; i < 3; i++) {
queue.offer(new Random().nextInt(10));
}
}
private void takeFromBuffer(Queue queue) {
Object obj;
while ((obj = queue.poll()) != null) {
System.out.print(obj + " ");
}
System.out.println();
}
class FillingLoop implements Runnable {
public void run() {
Queue currentQueue = new LinkedList<>();//初始
try {
while (currentQueue != null) {
if (currentQueue.isEmpty()) {
addToQueue(currentQueue);
}
currentQueue = exchanger.exchange(currentQueue);// 等待对方调用exchanger.exchange()时，交换Queue
}
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
class EmptyingLoop implements Runnable {
public void run() {
Queue currentQueue = new LinkedList<>();//初始
try {
while (currentQueue != null) {
if (!currentQueue.isEmpty()) {
takeFromBuffer(currentQueue);
}
currentQueue = exchanger.exchange(currentQueue);// 等待对方调用exchanger.exchange()时，交换Queue
}
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}