Java并发编程之CountDownLatch,CyclicBarrier,Semaphore的理解及应用场景

java.util.concurrent（J.U.C）大大提高了并发性能，AQS （AbstractQueuedSynchronizer） 被认为是 J.U.C 的核心。

CountDownLatch

用来控制一个或者多个线程等待多个线程。

维护了一个计数器 cnt，每次调用 countDown() 方法会让计数器的值减 1，减到 0 的时候，那些因为调用 await() 方法而在等待的线程就会被唤醒。

应用场景

张三、李四、王五约了某天一起聚餐，打算一起自己做饭，发现没有材料，于是各自出发去采购各种材料，采购好了后再回到聚餐点，一起开始做饭。

public class Cook implements Runnable {
    private CountDownLatch countDownLatch;
    private String action;

    public Cook(CountDownLatch countDownLatch, String action) {
        this.countDownLatch = countDownLatch;
        this.action = action;
    }

    @Override
    public void run() {
        try {
            Thread.sleep((1 + new Random().nextInt(5)) * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(new Date() + "：完成 " + action);
        countDownLatch.countDown();
    }
}

public class CookTask {
    public static void main(String[] args) {
        System.out.println(new Date() + "：开始准备材料，各自出发！");
        CountDownLatch countDownLatch = new CountDownLatch(3);
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(new Cook(countDownLatch, "张三买菜"));
        executorService.execute(new Cook(countDownLatch, "李四买锅"));
        executorService.execute(new Cook(countDownLatch, "王五买米"));
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(new Date() + "：材料准备齐全，开始做饭！");
        executorService.shutdown();
    }
}

Fri Oct 18 23:46:52 CST 2019：开始准备材料，各自出发！
Fri Oct 18 23:46:53 CST 2019：完成 王五买米
Fri Oct 18 23:46:54 CST 2019：完成 李四买锅
Fri Oct 18 23:46:56 CST 2019：完成 张三买菜
Fri Oct 18 23:46:56 CST 2019：材料准备齐全，开始做饭！

CyclicBarrier

用来控制多个线程互相等待，只有当多个线程都到达时，这些线程才会继续执行。

和 CountdownLatch 相似，都是通过维护计数器来实现的。线程执行 await() 方法之后计数器会减 1，并进行等待，直到计数器为 0，所有调用 await() 方法而在等待的线程才能继续执行。

CyclicBarrier 和 CountdownLatch 的一个区别是，CyclicBarrier 的计数器通过调用 reset() 方法可以循环使用，所以它才叫做循环屏障。

CyclicBarrier 有两个构造函数，其中 parties 指示计数器的初始值，barrierAction 在所有线程都到达屏障的时候会执行一次。

应用场景

张三、李四、王五约了某天一起旅游，导游通知他们统一到某集合点集合，导游在集合点讲解注意事项，讲解完后各自自由参观。

public class Travel implements Runnable {
    private CyclicBarrier cyclicBarrier;
    private String action;

    public Travel(CyclicBarrier cyclicBarrier, String action) {
        this.cyclicBarrier = cyclicBarrier;
        this.action = action;
    }

    @Override
    public void run() {
        try {
            Thread.sleep((1 + new Random().nextInt(5)) * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(new Date() + "：" + action + " 到达集合点");
        try {
            cyclicBarrier.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(new Date() + "：" + action + " 开始参观");
    }
}

public class Guide implements Runnable {

    @Override
    public void run() {
        System.out.println(new Date() + "：导游在集合点讲解注意事项，讲解完后各自自由参观！");
        try {
            Thread.sleep((1 + new Random().nextInt(5)) * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class TravelTask {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new Guide());
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(new Travel(cyclicBarrier, "张三"));
        executorService.execute(new Travel(cyclicBarrier, "李四"));
        executorService.execute(new Travel(cyclicBarrier, "王五"));
        executorService.shutdown();
    }
}

Fri Oct 18 23:48:14 CST 2019：王五 到达集合点
Fri Oct 18 23:48:15 CST 2019：李四 到达集合点
Fri Oct 18 23:48:16 CST 2019：张三 到达集合点
Fri Oct 18 23:48:16 CST 2019：导游在集合点讲解注意事项，讲解完后各自自由参观！
Fri Oct 18 23:48:18 CST 2019：张三 开始参观
Fri Oct 18 23:48:18 CST 2019：王五 开始参观
Fri Oct 18 23:48:18 CST 2019：李四 开始参观

Semaphore

Semaphore 类似于操作系统中的信号量，可以控制对互斥资源的访问线程数。

应用场景

假设有10个人在银行办理业务，只有3个工作窗口，代码实现逻辑如下。

public class SemaphoreExample {
    public static void main(String[] args) {
        final int clientCount = 3;
        final int totalRequestCount = 10;
        Semaphore semaphore = new Semaphore(clientCount, true);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < totalRequestCount; i++) {
            final int num = i + 1;
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(new Date() + "： 服务号 " + num + " 受理业务中...");
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println(new Date() + "： 服务号 " + num + " 离开");
                    semaphore.release();
                }
            });
        }
        executorService.shutdown();
    }
}

Sat Oct 19 16:33:59 CST 2019： 服务号 3 受理业务中...
Sat Oct 19 16:33:59 CST 2019： 服务号 2 受理业务中...
Sat Oct 19 16:33:59 CST 2019： 服务号 1 受理业务中...
Sat Oct 19 16:34:02 CST 2019： 服务号 2 离开
Sat Oct 19 16:34:02 CST 2019： 服务号 1 离开
Sat Oct 19 16:34:02 CST 2019： 服务号 3 离开
Sat Oct 19 16:34:02 CST 2019： 服务号 4 受理业务中...
Sat Oct 19 16:34:02 CST 2019： 服务号 5 受理业务中...
Sat Oct 19 16:34:02 CST 2019： 服务号 6 受理业务中...
Sat Oct 19 16:34:05 CST 2019： 服务号 4 离开
Sat Oct 19 16:34:05 CST 2019： 服务号 7 受理业务中...
Sat Oct 19 16:34:05 CST 2019： 服务号 5 离开
Sat Oct 19 16:34:05 CST 2019： 服务号 8 受理业务中...
Sat Oct 19 16:34:05 CST 2019： 服务号 6 离开
Sat Oct 19 16:34:05 CST 2019： 服务号 9 受理业务中...
Sat Oct 19 16:34:08 CST 2019： 服务号 7 离开
Sat Oct 19 16:34:08 CST 2019： 服务号 10 受理业务中...
Sat Oct 19 16:34:08 CST 2019： 服务号 8 离开
Sat Oct 19 16:34:08 CST 2019： 服务号 9 离开
Sat Oct 19 16:34:11 CST 2019： 服务号 10 离开