（一）等待多线程完成的CountDownLatch
CountDownLatch允许一个或多个线程等待其他线程完成操作。
假如有这样一个需求：我们需要解析一个Excel里多个sheet的数据，此时可以考虑使用多线程，每个线程解析一个sheet里的数据，等到所有的sheet都解析完之后，程序需要提示解析完 成。在这个需求中，要实现主线程等待所有线程完成sheet的解析操作，最简单的做法是使用 join()方法。
1.使用 join()方法控制主线程最后执行
/**
* sheet2 解析完成
* sheet1 解析完成
* sheet3 解析完成
* 所有sheet解析完成
*/
public class JoinCountDownLatchTest {
public static void main(String[] args) throws InterruptedException {
Thread t1 =new Thread(()->{
System.out.println("sheet1 解析完成");
});
Thread t2 =new Thread(()->{
System.out.println("sheet2 解析完成");
});
Thread t3 =new Thread(()->{
System.out.println("sheet3 解析完成");
});
t1.start();
t2.start();
t3.start();
t1.join();
t2.join();
t3.join();
System.out.println("所有sheet解析完成");
}
}
原理：join用于让当前执行线程等待join线程执行结束。其实现原理是不停检查join线程是否存 活，如果join线程存活则让当前线程永远等待。
2.使用CountDownLatch并发工具类控制主线程最后执行
/**
* Thread-0： 解析完成
* Thread-2： 解析完成
* Thread-1： 解析完成
* 所有sheet解析完成
*/
public class CountDownLatchTest {
public static void main(String[] args) throws InterruptedException {
//1.计数器初始值为3
CountDownLatch countDownLatch=new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"： 解析完成");
try {
Thread.sleep(300);
//2.每次减一
countDownLatch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
//3.await方法 会阻塞当前线程，直到N变成零
countDownLatch.await();
System.out.println("所有sheet解析完成");
}
}
注意：计数器必须大于等于0，只是等于0时候，计数器就是零，调用await方法时不会 阻塞当前线程。CountDownLatch不可能重新初始化或者修改CountDownLatch对象的内部计数 器的值。一个线程调用countDown方法happen-before，另外一个线程调await方法。
（二）同步屏障CyclicBarrier
CyclicBarrier的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会 开门，所有被屏障拦截的线程才会继续运行。
CyclicBarrier默认的构造方法是CyclicBarrier（int parties），其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。
1.CyclicBarrier（int parties）构造方法的使用
public class CyclicBarrierTest {
public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
//1.参数2表示屏障拦截的线程数量
CyclicBarrier cyclicBarrier = new CyclicBarrier(2);
new Thread(()->{
try {
//2.子线程调用await方法告诉诉CyclicBarrier我已经到达了屏障
cyclicBarrier.await();
System.out.println("sheet1");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
//3.主线程调用await方法告诉诉CyclicBarrier我已经到达了屏障
cyclicBarrier.await();
System.out.println("sheet2");
}
}
注意：
一般是主线程优先于子线程执行，但在这里主线程和子线程的调度是由CPU决定的，两个线程都有可能先执行，所以会产生两种输出，第一种：sheet1、sheet2 第二种：sheet2、sheet1。
如果把new CyclicBarrier(2)修改成new CyclicBarrier(3)，则主线程和子线程会永远等待，因为没有第三个线程执行await方法，即没有第三个线程到达屏障，所以之前到达屏障的两个 线程都不会继续执行。
CyclicBarrier还提供一个更高级的构造函数CyclicBarrier（int parties，Runnable barrier-Action），用于在线程到达屏障时，优先执行barrierAction，方便处理更复杂的业务场景。
2. CyclicBarrier的应用场景
CyclicBarrier可以用于多线程计算数据，最后合并计算结果的场景。例如，用一个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(()->{
sheetBankWaterCount.put(Thread.currentThread().getName(),1);
try {
c.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
});
}
}
//到达屏障拦截的线程数量，执行以下线程
@Override
public void run() {
int result = 0;
for(Map.Entry<String, Integer> sheet : sheetBankWaterCount.entrySet()){
result = result+sheet.getValue();
}
System.out.println("result = " + result);
}
public static void main(String[] args) {
BankWaterService bankWaterService = new BankWaterService();
bankWaterService.count();
}
}
3.CyclicBarrier和CountDownLatch的区别
- CountDownLatch是线程组之间的等待，即一个(或多个)线程等待N个线程完成某件事情之后再执行；而CyclicBarrier则是线程组内的等待，即每个线程相互等待，即N个线程都被拦截之后，然后依次执行。
- CountDownLatch是减计数方式，而CyclicBarrier是加计数方式。
- CountDownLatch计数为0无法重置，而CyclicBarrier计数达到初始值，则可以重置。
- CountDownLatch不可以复用，而CyclicBarrier可以复用。
（三）控制并发线程数的Semaphore
Semaphore（信号量）是用来控制同时访问特定资源的线程数量，它通过协调各个线程，以保证合理的使用公共资源。
@Slf4j
public class SemaphoreTest {
private final static int threadCount = 30;
public static void main(String[] args) throws Exception {
ExecutorService exec = Executors.newCachedThreadPool();
//表示允 许3个线程获取许可证，也就是最大并发数是3
final Semaphore semaphore = new Semaphore(3);
for (int i = 0; i < threadCount; i++) {
final int threadNum = i;
exec.execute(() -> {
try {
// 获取一个许可
semaphore.acquire();
//一次三个线程执行test方法
test(threadNum);
// 释放一个许可
semaphore.release();
} catch (Exception e) {
log.error("exception", e);
}
});
}
exec.shutdown();
}
private static void test(int threadNum) throws Exception {
log.info(Thread.currentThread().getName()+" is running");
Thread.sleep(10000);
}
}
在代码中，虽然有30个线程在执行，但是只允许3个并发执行。Semaphore的构造方法Semaphore（int permits）接受一个整型的数字，表示可用的许可证数量。Semaphore（3）表示允 许3个线程获取许可证，也就是最大并发数是3。Semaphore的用法也很简单，首先线程使用 Semaphore的acquire()方法获取一个许可证，使用完之后调用release()方法归还许可证。