Java 进阶——并发编程之线程同步利器CountDownLatch、CyclicBarrier、Semaphore 的使用小结
引言
Java 语言之所以广泛运用于服务端程序，很大一部分原因就是因为在JDK中Java 已经为我们提供了很多并发场景的解决方案，借助这些系统方案我们可以快速应用于具体场景，甚至是在系统方案上进行扩展，这篇文章就好好总结下三种线程控制工具类。
一、CountDownLatch
1、CountDownLatch概述
CountDownLatch 是一种允许一个或多个线程阻塞等待，直到在其他线程中的一系列操作完成之后，再继续执行的一次性同步机制（A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes）。简单理解CountDownLatch（内部是基于AbstractQueuedSynchronizer，篇幅问题不在此篇文章分析范围内）就是一个基于信号量机制的阻塞和唤醒线程的工具类，通过调用CountDownLatch提供的api方法就可以达到灵活阻塞和唤醒线程的目的。所谓信号量，其实和引用计数技术中的差不多，所以在初始化的时候需要给这个信号量赋一个数值（一般大于0），每调用CountDownLatch的countDown方法一次，信号量值减 1；若信号量当前值不为0时，调用await()方法的线程会被阻塞，直到count值为0才会继续执行；反之则不会阻塞。另外，CountDownLatch不可复用，计数不能重置。
2、CountDownLatch的主要方法
| 方法名称 | 说明 |
|---|---|
| public CountDownLatch(int count) | 通过指定信号量值构造CountDownLatch |
| public void await() | 调用await()方法的线程会被阻塞，直到count值为0才继续执行 |
| public boolean await(long timeout,TimeUnit unit) | 和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行 |
| public void countDown() | 将count值减1 |
3、CountDownLatch的简单应用
众所周知，即使我们几乎同时创建出若干条子线程，且每个子线程内部执行的工作一样，也不能保证每个子线程运行的顺序和结束的时间，因为启动过程和执行过程需要靠cpu 来调度，下面这个例子每次运行的结果也有所不同，但是基本上通过CountDownLatch都能保证主线程在每一组的所有子线程执行完毕之后再继续执行，总之调用await方法时后且当前信号量值不为0 调用线程则会被阻塞，而且一个线程可以被一个或者多个CountDownLatch控制。
- 通过CountDownLatch(int count)初始化创建CountDownLatch实例
- 根据具体场景在某个线程中调用await()或者await(long timeout,TimeUnit unit)方法尝试阻塞该线程
- 在线程内部或者其他线程调用 countDown()对计数减一
public class CountDownLatchDemo {
private final static int GROUP_SIZE = 3;
public static void main(String[] args) throws InterruptedException {
processOneGroup(第一组);
}
/**
*
* @param name
* @throws InterruptedException
*/
private static void processOneGroup(final String name)
throws InterruptedException {
final CountDownLatch mainCountDown = new CountDownLatch(GROUP_SIZE);//用于控制主线程的CountDownLatch
final CountDownLatch startCountDown = new CountDownLatch(1);//
System.out.println("***首先"+Thread.currentThread().getName()+"线程运行：" + "通过循环创建若干工作线程" + "***");
for (int i = 0; i < GROUP_SIZE; i++) {
new Thread(String.valueOf(i)) {
public void run() {
System.out.println(name + "的" + getName() + "线程已经准备就绪");
try {
startCountDown.countDown();
startCountDown.await();//如果startCountDown初始信号量值为1的话经过上一步的coutDown 当前信号量值已经为0 了 即使调用了await也无法阻塞
System.out.println("先调用await方法阻塞"+getName()+ "线程");
System.out.println(getName()+ "线程处理自己的工作ing");
Thread.sleep(3000);
mainCountDown.countDown();//主线程计数减一
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("子线程"+Thread.currentThread().getName() + "运行："+name + "的" + getName() + "线程已执行完毕");
}
}.start();
}
mainCountDown.await();// 等待所有子线程执行完毕
System.out.println("线程"+Thread.currentThread().getName() + "运行："+name + "中所有工作线程工作完毕");
//startCountDown.countDown();
System.out.println("----end线程"+Thread.currentThread().getName() + "继续执行------");
}
二、CyclicBarrier
1、CyclicBarrier概述
CyclicBarrier首先从字面上理解是Cyclic Barrier 即循环屏障。CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；而CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；而且CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。简而言之，CyclicBarrier可以让一组线程阻塞（暂且把这个状态就叫做barrier）直到barrier状态之后再全部（全部指的是getParties 获取到的所有等待线程）同时执行，当某个线程调用await()方法之后，该线程就处于barrier了。
2、CyclicBarrier的主要方法
| 方法名称 | 说明 |
|---|---|
| public CyclicBarrier(int parties) | parties：必须要调用await方法的线程数， |
| public CyclicBarrier(int parties, Runnable barrierAction) | barrierAction：clicBarrier到达 barrier状态时候要执行才操作 |
| public void await() | 调用await()方法的线程会被阻塞，直到CyclicBarrier上所有的线程（Waits until all getParties parties have invoked await on this barrier）都执行了await方法 |
| public boolean await(long timeout,TimeUnit unit) | 和await()类似，让这些线程等待至一定的时间，如果还有线程没有到达barrier状态，也直接让到达barrier的线程执行后续任务。 |
| public void reset() | 重用CyclicBarrier，将CyclicBarrier状态置为初始态，若当前还有其他线程在阻塞则会抛出BrokenBarrierException异常 |
3、CyclicBarrier的简单应用
3.1、CyclicBarrier的基本应用
package concurrent;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierDemo {
private static final int THREAD_COUNT=3;
/**
* 如果这里parties 不等于THREAD_COUNT会出现问题，可能会一直卡住
*/
private final static CyclicBarrier CYCLIC_BARRIER=new CyclicBarrier(THREAD_COUNT, new Runnable() {
@Override
public void run() {
System.out.println("全部团员已经结束上次行程，导游开始点名，准备进行下一个环节");
}
});
public static void main(String[] args) {
for(int i=0;i<3;i++){
new Thread(String.valueOf(i)){
public void run(){
try {
System.out.println("线程"+getName()+" 已到达旅游地点！");
CYCLIC_BARRIER.await();//阻塞当前线程
System.out.println("线程"+getName()+" 开始骑车");
Thread.sleep(2000);
CYCLIC_BARRIER.await();
System.out.println("线程"+getName()+" 开始爬山");
Thread.sleep(3000);
CYCLIC_BARRIER.await();
System.out.println("线程"+getName()+" 回宾馆休息");
Thread.sleep(1000);
CYCLIC_BARRIER.await();
System.out.println("线程"+getName()+" 开始乘车回家");
CYCLIC_BARRIER.await();
System.out.println("线程"+getName()+" 回家了");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
System.out.print(e.getMessage());
e.printStackTrace();
}
}
}.start();
}
}
}
3.2、CyclicBarrier的重用
package concurrent;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class ReuseCyclicBarrier {
public static void main(String[] args) {
final int THREAD_COUNT=3;
CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT, new Runnable() {
@Override
public void run() {
print("所有工作线程都已到达barrier状态");
}
});
print("*******第一组 使用 CyclicBarrier*********");
for(int i=0;inew Worker(barrier).start();
}
try {
Thread.sleep(9000);//此处为了保证主线程被阻塞直到第一组3个线程执行完毕所有的工作，所以至少要sleep 3000*3,如果少于则不会等到其他三个线程执行完毕之后才执行主线程
} catch (InterruptedException e) {
e.printStackTrace();
}
print("*************第二组 重用 CyclicBarrier***************\n");
//barrier.reset(); Resets the barrier to its initial state. If any parties are currently
//waiting at the barrier, they will return with a BrokenBarrierException
barrier = new CyclicBarrier(THREAD_COUNT-1, new Runnable() {
@Override
public void run() {
print("【重用】所有工作线程都已到达barrier状态");
}
});
for(int i=0;inew Worker(barrier).start();
}
}
static class Worker extends Thread{
private CyclicBarrier cyclicBarrier;
public Worker(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
try {
doWork(3000L);
print("操作数据完毕，等待其他工作线程"+"cyclicBarrier中的Parties数"+cyclicBarrier.getParties());
cyclicBarrier.await();//只是会阻塞，如果这里耗时很短的话，并不会阻塞主线程
}catch(BrokenBarrierException | InterruptedException e){
e.printStackTrace();
}
print("所有工作线程都已到达barrier状态后，所有线程执行操作完毕，继续处理其他任务...");
}
}
public static void print(String s) {
System.out.println(Thread.currentThread().getName()+" 线程 : "+s);
}
public static void doWork(long mills){
try {
print("正在操作数据ing");
Thread.sleep(mills);//以睡眠来模拟数据操作
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
三、Semaphore
1、Semaphore 概述
Semaphore首先从字面上理解是 信号量，Semaphore可以控制同时访问某组资源的线程个数，Semaphore当前在多线程环境下被广泛使用，操作系统的信号量是个很重要的概念，在进程控制方面都有应用。Java 并发库 的Semaphore 可以很轻松完成信号量控制可以通过 acquire() 方法获取一个许可，如果没有就阻塞；而 release() 方法释放一个许可，其实Semaphore和锁机制有点类似，信号量一般用于控制对 某组 资源的访问权限，而锁是控制对 某个 资源的访问权限。
2、Semaphore 的主要方法
| 方法名称 | 说明 |
|---|---|
| public Semaphore(int permits) | permits：一组资源最大同时可以被permits个线程所访问 |
| public Semaphore(int permits, boolean fair) | fair：和阻塞队列一样用于标识是否采用公平的访问优先策略，true：按照先来后到的顺序获得机会；false：随机获得优先机会 |
| public void acquire() | 获取一个许可，若无许可能够获得，则会一直阻塞，直到获得许可。 |
| public void acquire(int permits) | 获取permits个许可 |
| public void release() | 释放一个许可，在释放许可之前，必须先获获得许可 |
| public void release(int permits) | 释放permits个许可 |
| 以上四种方法都会阻塞，下面tryXXX的不会阻塞—————— | |
| public boolean tryAcquire() | 尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false |
| public boolean tryAcquire(long timeout, TimeUnit unit) | 尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false |
| public boolean tryAcquire(int permits) | 尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false |
| public boolean tryAcquire(int permits, long timeout, TimeUnit unit) | 尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false |
3、Semaphore 的简单应用
举个例子每一层楼指纹打卡机只有3台，而打卡的员工远不止，那么为了更高效率，只得确保同时只能有3个人能够使用，而当这3个人中的任何一个人打卡完毕离开后，剩下正在等待的其他人中马上又有1个人可以使用了（这个人可以是等待队伍中的任意一个，可以是随机获得优先机会，也可以是按照先来后到的顺序获得机会）这取决于构造Semaphore对象时传入的参数选项。另外单个信号量的Semaphore对象可以实现互斥锁的功能，并且可以是由一个线程获得了“锁”，再由另一个线程释放“锁”，这可应用于死锁恢复的一些场合。
package concurrent;
import java.util.Random;
import java.util.concurrent.Semaphore;
/**
* 假如一个工厂有3台打卡机，但是有6名员工，一台机器同时只能被一个员工使用，只有使用完了，其他员工才能继续使用
* @author Crazy.Mo
*
*/
public class SemaphoreTest {
public static void main(String[] args) {
final int WORKER_NUM = 6; //总员工数
final int SOURCE_COUNT=3;//3台指纹打卡机，一组资源
Semaphore semaphore = new Semaphore(SOURCE_COUNT); //最大同时允许SOURCE_COUNT 个员工使用
for(int i=0;inew FingerPrint(i,semaphore).start();
}
}
static class FingerPrint extends Thread{
private int num;
private Semaphore semaphore;
public FingerPrint(int num,Semaphore semaphore){
this.num = num;
this.semaphore = semaphore;
}
@Override
public void run() {
try {
semaphore.acquire();
print("员工"+this.num+"正在使用一台指纹打卡机ing。。。");
Thread.sleep(new Random().nextInt(3000));
print("员工"+this.num+"释放出一台指纹打卡机");
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void print(String s) {
System.out.println(Thread.currentThread().getName()+" 线程 : "+s);
}
public static void doWork(long mills){
try {
Thread.sleep(mills);//以睡眠来模拟打卡
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} 