Java多线程-CountDownLatch、CyclicBarrier、Semaphore

上次简单了解了多线程中锁的类型，今天要简单了解下多线程并发控制的一些工具类了。

1. 概念说明：

CountDownLatch：相当于一个待执行线程计数器，当计数减为零时表示所有待执行线程都已执行完毕，等待被计数线程结果的（即使用await()的）线程可以继续执行（await()后面的代码）了。

CyclicBarrier：可循环屏障，相当于一个准备执行线程计数器，当计数减为零时表示所有待执行线程（这些线程需要同时开始工作）都已做好准备工作，可以开始工作了。

Semaphore：允许并发线程数，semaphore.acquire()和semaphore.release()方法总是成对出现，而这对方法之间的代码最多允许多少个线程访问是由Semaphore semaphore=new Semaphore(n)的n决定的。

2. 构造实际场景，使用示例

设想一个赛跑场景，一共有10个运动员参赛，所有运动员必须同时起跑（CyclicBarrier控制），而计分结束必须在所有运动员都跑完全程之后（CountDownLatch控制），但是学校操场只有4条跑道（Semaphore），那么就要让运动员分三批进行比赛，每次最多4人入场：

 import com.alibaba.fastjson.JSONObject;
 import org.apache.commons.lang3.concurrent.BasicThreadFactory;
 import org.junit.Test;

 import java.util.concurrent.*;

 public class MultiThreadsTest {
     private volatile ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
     // 声明一个线程池，用于线程管理
     ThreadPoolExecutor executor = new ThreadPoolExecutor(4, 4,
             20, TimeUnit.MICROSECONDS, new LinkedBlockingQueue<>(),
             new BasicThreadFactory.Builder().namingPattern("Runner-%d").build(),
             new ThreadPoolExecutor.CallerRunsPolicy());

     @Test
     public void testMultiControl() {
         // 跑道数
         int runways = 4;
         // 参赛总人数
         int runners = 10;
         // 参赛人数多于跑道数，需分批比赛
         int batch = 1;
         // 当运动员总数多于跑道数，最多runways人入场
         while (runners >= runways) {
             runningGame(batch++, runways);
             runners = runners - runways;
         }
         // 最后一批，还剩几个人，就几个人入场
         runningGame(batch, runners);
         System.out.println("\n所有选手都已跑完，现在宣布比赛结果:\n" + JSONObject.toJSONString(map));
     }

     private void runningGame(int batch, int runners) {
         System.out.println("第" + batch + "批，共" + runners + "人，运动员正在进场...");
         // 每批允许runways个运动员入场
         Semaphore semaphore = new Semaphore(runners);
         // 每批runways个运动员必须都准备好，同时起跑
         CyclicBarrier barrier = new CyclicBarrier(runners);
         // 每批runways个运动员都跑完全程，裁判这一批计分结束
         CountDownLatch latch = new CountDownLatch(runners);
         for (int i = runners; i > 0; i--) {
             // 每个运动员都是一个独立奔跑的线程
             executor.execute(() -> {
                 try {
                     // 每个运动员进场都会占用一个跑道
                     semaphore.acquire();
                     // 每个运动员就位都会通知barrier，等所有跑道上的运动员都就位，大家就一起跑！
                     barrier.await();
                     running(Thread.currentThread().getName());
                     // 每个运动员跑完都要让出自己的跑道（为下一批运动员让路）
                     semaphore.release();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 } catch (BrokenBarrierException e) {
                     e.printStackTrace();
                 } finally {
                     // 每个运动员跑完都要通知裁判为自己计分
                     latch.countDown();
                 }
             });
         }
         try {
             // 跑道上所有运动员都跑完，则裁判计分结束
             latch.await();
             System.out.println("第" + batch + "批，共" + runners + "人，计分结束");
         } catch (InterruptedException e) {
             System.out.println(e.getStackTrace());
         }
     }

     private void running(String name) {
         long start = System.currentTimeMillis();
         System.out.println(name + " running started ...");
         System.out.println(name + ": I'm running.\taudience: Yes, I see.\t" + name + ":I'm done running.\taudience: Well done!");
         try {
             // 跑太快，歇会儿
             TimeUnit.MILLISECONDS.sleep(2);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println(name + " running completed");
         // 裁判将所有运动员的分数都记录在map中
         map.put(name, (System.currentTimeMillis() - start) + "ms");
     }
 }

运行结果

3. 代码运行结果分析：

乍看上面代码和运行结果好像都没什么问题，每批允许4人进场，总是同时开始跑，也都等到每批选手都跑完后该批计分结束，countDownLatch和CyclicBarrier确实都起到了各自的作用，但是Semaphore呢？好像也确实是限制了只允许4个线程同时访问这段代码，然而在你一次只有4个选手的情况下，它当然是最多4个线程访问了，其实Semaphore的工作已经由方法入参给限定了啊，Semaphore的作用何在呢？那么假如学校原本有4个跑道，但是比赛开始之后却发现有一个入场通道坏了，变成了每次只能有3个人入场，但是场内的裁判并不知道，还在等待着按每4人一批进行比赛，那将会是什么结果呢？

我们修改代码看下：其他部分不变，只把允许入场的运动员数减1，然后再运行Test发现程序一直处于“第一批运动员进场”过程中，说明Semaphore这个变量已经起到了它的作用，就是每次只允许3个运动员进场，而且放入3个运动员后就会进行等待，等待这3个运动员比赛结束再放下一批进场，而场内的裁判并不知道可入场人数已经变化，还在等待着第4名选手入场才吹响开跑号声，因此入场管理员Semaphore和起跑裁判官CyclicBarrier就会陷入无法终止的相互等待，程序一直无法打破这种等待循环，因而进入停滞状态，这就是一种简单的死锁场景了。

4. 总结

这里只是简单说明这三个工具有用法，场景并不十分合理，其实这三者通常独立使用，一般不会碰到三者同时上场的机会。