JUC之ContDownLatch CyclicBarrier Semaphore使用记录

水平有限，只记录使用方法和个人理解，不保证全对

闲聊

• 第一次学习到JUC时候应该是19年，JUC包下的AQS和CAS 并发容器 相关的类都了解了一遍。当时想记录下来但是又觉得理解不够深刻。日常工作中又很少会用到相关的知识。所以一直搁浅到现在。中间陆陆续续遗忘又捡起。
• 慢慢的发现如果只有学习没有产出，学习的意义好像就是当你遇到一个场景会想到有这种解决方案，然后继续去找这方面的东西重新补充。
• 所以试着以当下的状态去叙述这些东西，也算是以后再拿起的索引

ContDownLatch

• ContDownLatch是一个同步辅助类，用于阻塞一个或者多个线程的工具类。多用于阻塞当前主线程执行，等待字线程的执行结果。
• 当所有线程准备就绪，才开始执行
• 创建时候指定初始值，每一个线程执行完后调用countDown方法来表述自己任务执行完毕，所有线程执行完之后，被await方法阻塞的线程开始继续执行
• 1+2+3+4 的计算，同时两个线程去计算一个线程执行1+2 另一个线程执行 3+ 4 再将子线程的结果累加，所以主线程是需要子线程的执行结果，需要等子线程都执行完毕之后在继续执行的。
• 比如打英雄联盟的时候十个人都准备好了，然后就开始团战。

public class CountDownLatchDemo {

    private static final int THREAD_COUNT = 10;

    private static final CountDownLatch countDownLatch = new CountDownLatch(THREAD_COUNT);

    private static final ExecutorService executorService = ThreadUtil.newExecutor(THREAD_COUNT, THREAD_COUNT * 2);

    public static void main(String[] args) throws Exception {

        for (int i = 0; i < 10; i++) {
            final int threadNum = i;
            executorService.execute(() -> {
                try {
                    ready(threadNum);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
        countDownLatch.await();// 主线程阻塞,等待所有子线程到达屏障
        executorService.shutdown();
        System.out.println("开打!开打!");
    }

    private static void ready(int threadNum) throws Exception {
        Thread.sleep(1000);// 补充状态,技能冷却
        System.out.println("英雄" + threadNum + "准备就绪");
        countDownLatch.countDown();// 线程到达屏障
    }
}

CyclicBarrier

• CyclicBarrier和CountDownLatch 有很多相似之处，首先都是基于计数器实现，但是有着比CountDownLatch 更多的应用场景和更强大的功能。
• 可以使多个线程之间相互等待，只有等所有的线程都执行完毕之后才会继续往下执行
• 当调用await()时线程会进入等待，等待的线程数到达我们设定的初始值后，线程继续执行
• 当CyclicBarrier释放线程后可以重用所以也称之为可循环栅格
• 玩过英雄联盟的人应该都知道出门慢输一半，所以一波公平的团战，应该等大家都准备就绪才开始，这才是竞技精神。
• 所以正常的团战逻辑应该是大家回家补充状态，等待技能冷却，然后回到中路，开始团战，活下来的人才有资格补刀。

public class CyclicBarrierDemo {
    private static final int THREAD_COUNT = 10;

    // 十个英雄,主线程需要等待所有子线程所以 10 + 1
    private final static CyclicBarrier cyclicBarrier = new CyclicBarrier(11);

    private static final ExecutorService executorService = ThreadUtil.newExecutor(THREAD_COUNT, THREAD_COUNT * 2);

    public static void main(String[] args) throws Exception {

        for (int a = 0; a < 2; a++) {
            for (int i = 0; i < 10; i++) {
                final int threadNum = i;
                final int threadCou = a;
                executorService.execute(() -> {
                    try {
                        ready(threadNum, threadCou);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
            }
            // 需要等所有的英雄都准备就绪
            cyclicBarrier.await();
            if(a == 0){
                System.out.println("所有英雄准备就绪,准备出发");
            }
        }
        System.out.println("开打!开打!");
        executorService.shutdown();
    }

    private static void ready(int threadNum, int threadCou) throws Exception {
        Thread.sleep(1000);// 补充状态,技能冷却
        if(threadCou == 0){
            System.out.println("英雄" + threadNum + "准备就绪");
        }else {
            System.out.println("英雄" + threadNum + "到达战场");
        }
        cyclicBarrier.await();
    }
    
}

Semaphore

• Semaphore可以控制一个资源可以同时被访问的次数。
• 比如在数据库连接池中的时候用

public class SemaphoreDemo {

    private static final int THREAD_COUNT = 4;

    private static final Semaphore semaphore = new Semaphore(2);

    private static final ExecutorService executorService = ThreadUtil.newExecutor(THREAD_COUNT, THREAD_COUNT * 2);

    public static void main(String[] args) {
        for (int i = 0; i < 4; i++) {
            final int threadNum = i;
            executorService.execute(() -> {
                try {
                    if (semaphore.availablePermits() == 0) {
                        System.out.println(threadNum + "----->> 等待获取连接");
                    }
                    semaphore.acquire();// 获取凭证
                    ready(threadNum);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
        executorService.shutdown();
    }

    private static void ready(int threadNum) throws Exception {
        System.out.println(threadNum + "连接被获取");
        Thread.sleep(2000); // sql执行需要时间
        System.out.println("sql执行完毕" + threadNum + "归还");
        semaphore.release();// 释放凭证
    }

}