在JUC中，有三个工具类来辅助我们进行并发编程，分别是
CountDownLatch，CyclicBarrier和Semaphore
CountDownLatch
英文意味倒计时器。顾名思义，它能够让某个线程等待，直到倒计时结束再执行。
假如我想让主线程最后执行。看如下代码（未加CountDownLatch）：
public class CountDownLatchTest {
public static void main(String[] args) {
int t = 5;
for (int i = 0;i<t;i++){
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"正在执行");
}).start();
}
System.out.println("主线程执行");
}
}
---------------结果----------------
主线程执行
Thread-1正在执行
Thread-2正在执行
Thread-0正在执行
Thread-3正在执行
Thread-4正在执行
现在加上CountDownLatch
public class CountDownLatchTest {
public static void main(String[] args) throws InterruptedException {
int t = 5;
CountDownLatch countDownLatch = new CountDownLatch(t);
for (int i = 0;i<t;i++){
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"正在执行");
countDownLatch.countDown();
}).start();
}
countDownLatch.await();
System.out.println("主线程执行");
}
}
------------结果------------
Thread-0正在执行
Thread-2正在执行
Thread-3正在执行
Thread-1正在执行
Thread-4正在执行
主线程执行
CyclicBarrier
字面意思回环栅栏。就是让一组线程等待至同一个状态后再继续全部执行。
看如下代码，假设我想让全部线程先打印第一句话后再打印第二句话，最后在打印第三句话
未加CyclicBarrier
public class CyclicBarrierTest {
public static void main(String[] args) {
int t = 5;
for (int i = 0;i<t;i++){
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"开始执行");
System.out.println(Thread.currentThread().getName()+"正在执行");
System.out.println(Thread.currentThread().getName()+"执行完毕");
}).start();
}
}
}
------------结果-------------
Thread-0开始执行
Thread-2开始执行
Thread-1开始执行
Thread-1正在执行
Thread-2正在执行
Thread-2执行完毕
Thread-1执行完毕
Thread-0正在执行
Thread-3开始执行
Thread-3正在执行
Thread-3执行完毕
Thread-4开始执行
Thread-4正在执行
Thread-4执行完毕
Thread-0执行完毕
加上CyclicBarrier
public class CyclicBarrierTest {
public static void main(String[] args) {
int t = 5;
CyclicBarrier cyclicBarrier = new CyclicBarrier(t);
for (int i = 0;i<t;i++){
new Thread(()->{
try {
System.out.println(Thread.currentThread().getName()+"开始执行");
cyclicBarrier.await();
System.out.println(Thread.currentThread().getName()+"正在执行");
cyclicBarrier.await();
System.out.println(Thread.currentThread().getName()+"执行完毕");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
}
------------结果-------------
Thread-0开始执行
Thread-2开始执行
Thread-1开始执行
Thread-3开始执行
Thread-4开始执行
Thread-4正在执行
Thread-2正在执行
Thread-3正在执行
Thread-0正在执行
Thread-1正在执行
Thread-1执行完毕
Thread-3执行完毕
Thread-2执行完毕
Thread-4执行完毕
Thread-0执行完毕
CyclicBarrier还提供Runnable参数，可以在所有线程执行完毕后进行额外操作
代码如下：
public class CyclicBarrierTest {
public static void main(String[] args) {
int t = 5;
CyclicBarrier cyclicBarrier = new CyclicBarrier(t, new Runnable() {
@Override
public void run() {
System.out.println("======================");
}
});
for (int i = 0;i<t;i++){
new Thread(()->{
try {
System.out.println(Thread.currentThread().getName()+"开始执行");
cyclicBarrier.await();
System.out.println(Thread.currentThread().getName()+"正在执行");
cyclicBarrier.await();
System.out.println(Thread.currentThread().getName()+"执行完毕");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
}
-----------结果--------------
Thread-0开始执行
Thread-1开始执行
Thread-3开始执行
Thread-4开始执行
Thread-2开始执行
======================
Thread-2正在执行
Thread-0正在执行
Thread-3正在执行
Thread-1正在执行
Thread-4正在执行
======================
Thread-4执行完毕
Thread-2执行完毕
Thread-1执行完毕
Thread-3执行完毕
Thread-0执行完毕
Semaphore
意为信号量。有点像锁，是对锁的扩展。信号量可以指定多个线程同时访问一个资源，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。
假设银行有5个窗口，10个顾客，只有当窗口被释放了，下一个顾客才能去办业务；
用Semaphore的话很容易就实现
public class SemaphoreTest {
public static void main(String[] args) {
int t = 10;
Semaphore semaphore = new Semaphore(5);
for (int i = 0;i<t;i++){
int finalI = i;
new Thread(()->{
try {
semaphore.acquire();
System.out.println("顾客"+ finalI +"正在办理业务，占用窗口");
Thread.sleep(2000);
System.out.println("顾客"+ finalI +"业务办理成功，释放窗口");
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
}
-----------结果--------------
顾客0正在办理业务，占用窗口
顾客1正在办理业务，占用窗口
顾客2正在办理业务，占用窗口
顾客3正在办理业务，占用窗口
顾客4正在办理业务，占用窗口
顾客0业务办理成功，释放窗口
顾客5正在办理业务，占用窗口
顾客2业务办理成功，释放窗口
顾客1业务办理成功，释放窗口
顾客6正在办理业务，占用窗口
顾客7正在办理业务，占用窗口
顾客3业务办理成功，释放窗口
顾客8正在办理业务，占用窗口
顾客4业务办理成功，释放窗口
顾客9正在办理业务，占用窗口
顾客5业务办理成功，释放窗口
顾客8业务办理成功，释放窗口
顾客7业务办理成功，释放窗口
顾客9业务办理成功，释放窗口
顾客6业务办理成功，释放窗口
总结
CountDownLatch和CyclicBarrier 都能实现线程之间的等待。
CountDownLatch是让某线程在其他所有线程都执行后才执行。
CyclicBarrier是让一组相互等待到某一个阶段后再继续一起往下执行。
Semaphore有点像锁，一般用于控制对某组资源的访问权限。
