聊聊并发（三）——同步辅助类

一、概述

1、介绍

　　JUC 中提供了三种常用的辅助类，通过这些辅助类可以很好的解决线程数量过多时 Lock 锁的频繁操作。这三种辅助类为：
　　CountDownLatch：减少计数。减一计数器。
　　CyclicBarrier：循环栅栏。加一计数器。
　　Semaphore：信号灯。

　　脑图：https://www.processon.com/view/link/61849ba4f346fb2ecc4546e5

二、CountDownLatch（闭锁）

1、班长关门问题

　　场景一：6 个同学陆续离开教室后，班长才可以关门。
　　代码示例：

public class CountDownLatchDemo {
    public static void main(String[] args) {
        // 设置一个计数器 为 6
        CountDownLatch latch = new CountDownLatch(6);

        // 开启6个线程,来模拟6个同学
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                try {
                    // 生成 5s 以内的随机数,这里仅仅只是让打印更生动.
                    Thread.sleep(new Random().nextInt(5) * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + "离开教室了~");

                // 计数器 -1
                latch.countDown();
            }, i + " 号同学").start();
        }

        // 这里main线程模拟班长.班长要等上面6个线程都执行完,才执行.
        // 当计数器为0,即上面 6 个线程都执行完.因await方法阻塞的线程会被唤醒,继续执行.
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("班长关门了~");
    }
}

// 可能的一种结果
5 号同学离开教室了~
3 号同学离开教室了~
2 号同学离开教室了~
6 号同学离开教室了~
1 号同学离开教室了~
4 号同学离开教室了~
班长关门了~

2、裁判运动员问题

　　场景二：田径运动会上，起跑前所有运动员等待裁判发枪声为准开始比赛。典型的多个线程等待一个线程。
　　代码示例：

public class CountDownLatchDemo {
    public static void main(String[] args) {
        // 设置一个计数器 为 1
        CountDownLatch latch = new CountDownLatch(1);

        // 开启6个线程,来模拟6个运动员
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                try {
                    latch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + "起跑~");

            }, i + " 号运动员").start();
        }

        System.out.println("裁判发出枪声,比赛开始~");
        // 计数器减1变为0.因await方法阻塞的线程会被唤醒,继续执行.
        latch.countDown();
    }
}

// 可能的一种结果
裁判发出枪声,比赛开始~
2 号运动员起跑~
1 号运动员起跑~
3 号运动员起跑~
4 号运动员起跑~
5 号运动员起跑~
6 号运动员起跑~

　　场景三：田径运动会上，终点处，计时裁判需要等待所有运动员到达终点，才能宣布本次比赛结束。典型的一个线程等待多个线程。
　　代码示例：

public class CountDownLatchDemo {
    public static void main(String[] args) {
        // 设置一个计数器 为 6
        CountDownLatch latch = new CountDownLatch(6);

        // 开启6个线程,来模拟6个运动员
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                try {
                    // 生成 5s 以内的随机数,这里仅仅只是让打印更生动.
                    Thread.sleep(new Random().nextInt(5) * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + "达到终点~");
                
                // 计数器-1
                latch.countDown();
            }, i + " 号运动员").start();
        }

        try {
            // 主线程在这里阻塞,当latch的计数器减为0,才会被唤醒,继续执行.
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("所有运动员达到,裁判宣布比赛结束~");
    }
}

// 可能的一种结果
1 号运动员达到终点~
2 号运动员达到终点~
6 号运动员达到终点~
4 号运动员达到终点~
3 号运动员达到终点~
5 号运动员达到终点~
所有运动员达到,裁判宣布比赛结束~

三、CyclicBarrier（循环栅栏）

// 构造器
public CyclicBarrier(int parties, Runnable barrierAction) {
    if (parties <= 0) throw new IllegalArgumentException();
    this.parties = parties;
    this.count = parties;
    this.barrierCommand = barrierAction;
}

int parties：目标障碍数
Runnable barrierAction：达到目标障碍数后,需要执行的方法.

　　每执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行目标方法。可以将 CyclicBarrier 理解为加一计数器。

1、七龙珠收集问题

　　代码示例：

public class CyclicBarrierDemo {
    // 召唤神龙
    private final static int NUM = 7;

    public static void main(String[] args) {

        CyclicBarrier cyclicBarrier = new CyclicBarrier(NUM, () -> {
            // 当栅栏数到达7时,执行此方法
            System.out.println("集齐" + NUM + "颗龙珠,召唤神龙~");
        });

        // 开启7个线程,去收集龙珠
        for (int i = 1; i <= 7; i++) {
            new Thread(() -> {
                try {
                    try {
                        // 生成 5s 以内的随机数,这里仅仅只是让打印更生动.
                        Thread.sleep(new Random().nextInt(5) * 1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "收集到了~");

                    // 栅栏数 +1
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, i + " 星龙珠").start();
        }
    }
}

// 可能的一种结果
6 星龙珠收集到了~
7 星龙珠收集到了~
2 星龙珠收集到了~
3 星龙珠收集到了~
1 星龙珠收集到了~
5 星龙珠收集到了~
4 星龙珠收集到了~
集齐7颗龙珠,召唤神龙~

四、Semaphore（信号灯）

1、介绍

　　一个计数信号量。在概念上，信号量维持一组许可证。如果有必要，每个acquire()都会阻塞，直到许可证可用，然后才能使用它。每个release()添加许可证，潜在地释放阻塞获取方。但是，没有使用实际的许可证对象。Semaphore只保留可用数量的计数，并相应地执行。使用 acquire() 方法获得许可证，release() 方法释放许可。
　　理解：就是多个线程一起抢多把锁。

2、抢车位问题

　　代码示例：6辆车抢2个车位

public class SemaphoreDemo {
    public static void main(String[] args) {
        // 设置 2 个车位
        Semaphore semaphore = new Semaphore(2);

        // 开启6个线程,来模拟6辆车
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                try {
                    // 1.获取许可证.表示抢到了车位
                    semaphore.acquire();

                    System.out.println(Thread.currentThread().getName() + " 抢到了车位,开始停车~");
                    // 生成5s以内的随机数,表示停车了 time 秒
                    final long time = new Random().nextInt(5) * 1000;
                    Thread.sleep(time);

                    System.out.println(Thread.currentThread().getName() + " 停车了 " + time / 1000 + " 秒,开走了~");
                    // 2.释放许可证.表示车开走了
                    semaphore.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, i + " 号车").start();
        }
    }
}

// 可能的一种结果
1 号车 抢到了车位,开始停车~
2 号车 抢到了车位,开始停车~
2 号车 停车了 3 秒,开走了~
3 号车 抢到了车位,开始停车~
1 号车 停车了 4 秒,开走了~
4 号车 抢到了车位,开始停车~
4 号车 停车了 1 秒,开走了~
5 号车 抢到了车位,开始停车~
3 号车 停车了 2 秒,开走了~
6 号车 抢到了车位,开始停车~
6 号车 停车了 3 秒,开走了~
5 号车 停车了 4 秒,开走了~

　　这里，Semaphore的构造器参数是2，表示有2个许可证。所以，可以同时停下2辆车。结果不难分析。

　　参考文档：https://www.matools.com/api/java8