JUC系列（七）| JUC三大常用工具类CountDownLatch、CyclicBarrier、Semaphore

public void countDown() {
    sync.releaseShared(1);
}

public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

/**
 * @Author: crush
 * @Date: 2021-08-19 23:21
 * version 1.0
 */
public class CountDownLatchDemo1 {
    public static void main(String[] args) {
        // 初始值8 有八个人需要出寝室门
        CountDownLatch countDownLatch = new CountDownLatch(8);
        for (int i = 1; i <= 8; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "出去啦");
                // 出去一个人计数器就减1
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }
        try {
            countDownLatch.await(); // 阻塞等待计数器归零
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 阻塞的操作 ： 计数器  num++
        System.out.println(Thread.currentThread().getName() + "====寝室人都已经出来了，关门向教室冲！！！====");
    }
}

public class CyclicBarrier {
    private int dowait(boolean timed, long nanos); // 供await方法调用 判断是否达到条件 可以往下执行吗
    //创建一个新的CyclicBarrier,它将在给定数量的参与方（线程）等待时触发，每执行一次CyclicBarrier就累加1，达到了parties，就会触发barrierAction的执行
    public CyclicBarrier(int parties, Runnable barrierAction) ;
    //创建一个新的CyclicBarrier ，参数就是目标障碍数,它将在给定数量的参与方（线程）等待时触发，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后的语句
    public CyclicBarrier(int parties) 
  //返回触发此障碍所需的参与方数量。
    public int getParties()
    //等待，直到所有各方都在此屏障上调用了await 。
  // 如果当前线程不是最后一个到达的线程，那么它会出于线程调度目的而被禁用并处于休眠状态.直到所有线程都调用了或者被中断亦或者发生异常中断退出
    public int await()
    // 基本同上 多了个等待时间 等待时间内所有线程没有完成，将会抛出一个超时异常
    public int await(long timeout, TimeUnit unit)
    //将障碍重置为其初始状态。 
    public void reset()
}

/**
 * @Author: crush
 * @Date: 2021-08-20 13:18
 * version 1.0
 */
public class CyclicBarrierDemo1 {
    public static void main(String[] args) {
        // 第一个参数：目标障碍数  第二个参数：一个Runnable任务，当达到目标障碍数时，就会执行我们传入的Runnable
        // 当我们抽了201次的时候，就会执行这个任务。
        CyclicBarrier cyclicBarrier = new CyclicBarrier(201,()->{
            System.out.println("恭喜你，已经抽奖201次，幸运值已满，下次抽奖必中荣耀水晶！！！");
        });
        for (int i=1;i<=201;i++){
            final int count=i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"抽奖一次");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
    // 这行代码是重置计数
    cyclicBarrier.reset();
    // 这里是我又加了 一次循环， 可以看到最后结果中输出了两次 "恭喜你"
    for (int i=1;i<=201;i++){
        final int count=i;
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"抽奖一次");
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        },String.valueOf(i)).start();
    }
}

/**
 * @Author: crush
 * @Date: 2021-08-20 14:03
 * version 1.0
 */
public class SemaphoreDemo1 {
    public static void main(String[] args) {
        // 10台电脑
        Semaphore semaphore = new Semaphore(10);
        // 20 个小伙伴想要上网
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                try {
                    //等待获取许可证
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "抢到了电脑");
                    //抢到的小伙伴，迅速就开打啦 这里就模拟个时间哈，
                    TimeUnit.SECONDS.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //打完几把游戏的小伙伴 女朋友来找了 溜啦溜啦 希望大家都有人陪伴
                    System.out.println("女朋友来找，"+Thread.currentThread().getName() + "离开了");
                    semaphore.release();//释放资源,离开了就要把电脑让给别人啦。
                }
            }, String.valueOf(i)).start();
        }
    }
}

//默认的构造方法，初始化注册的线程数量为0,可以动态注册
Phaser();
//指定了线程数量的构造方法
Phaser(int parties);
//添加一个注册者  向此移相器添加一个新的未到达方。 如果正在进行对onAdvance调用，则此方法可能会在返回之前等待其完成。
register();
//添加指定数量的注册者  将给定数量的新未到达方添加到此移相器(移相器就是Phaser)。
bulkRegister(int parties);
// 到达屏障点直接执行 无需等待其他人到达。
arrive();
//到达屏障点后，也必须等待其他所有注册者到达这个屏障点才能继续下一步
arriveAndAwaitAdvance();
//到达屏障点，把自己注销了，不用等待其他的注册者到达
arriveAndDeregister();
//多个线程达到注册点之后，会回调这个方法，可以做一些逻辑的补充
onAdvance(int phase, int registeredParties);

package com.crush.juc05;
import java.util.concurrent.Phaser;
public class PhaserDemo {
    private static Phaser phaser = new MyPhaser();
    //自定义一个移相器来自定义输出
    static class MyPhaser extends Phaser {
        /**
         * @deprecated 在即将到来的阶段提前时执行操作并控制终止的可覆盖方法。 此方法在推进此移相器的一方到达时调用（当所有其他等待方处于休眠状态时）。
         *             如果此方法返回true ，则此移相器将在提前时设置为最终终止状态，并且对isTerminated后续调用将返回 true。
         * @param phase 进入此方法的当前阶段号，在此移相器前进之前
         * @param registeredParties 当前注册方的数量
         * @return
         */
        @Override
        protected boolean onAdvance(int phase, int registeredParties) {
            if (phase == 0) {
                System.out.println("所有人都到达了网吧，准备开始开黑！！！");
                return false;
            } else if (phase == 1) {
                System.out.println("大家都同意，一起去次烧烤咯！！！");
                return false;
            } else if (phase == 2) {
                System.out.println("大家一起回寝室！！！");
                return true;
            }
            return true;
        }
    }
    //构建一个线程任务
    static class DoSomeThing implements Runnable {
        @Override
        public void run() {
            /**
             * 向此移相器添加一个新的未到达方
             */
            phaser.register();
            System.out.println(Thread.currentThread().getName() + "从家里出发，准备去学校后街上网开黑！！！");
            phaser.arriveAndAwaitAdvance();
            System.out.println(Thread.currentThread().getName() + "上着上着饿了，说去次烧烤吗？");
            phaser.arriveAndAwaitAdvance();
            System.out.println(Thread.currentThread().getName() + "烧烤次完了");
            phaser.arriveAndAwaitAdvance();
        }
    }
    public static void main(String[] args) throws Exception {
        DoSomeThing thing = new DoSomeThing();
        new Thread(thing, "小明").start();
        new Thread(thing, "小王").start();
        new Thread(thing, "小李").start();
    }
}
/**
 * 小李从家里出发，准备去学校后街上网开黑！！！
 * 小王从家里出发，准备去学校后街上网开黑！！！
 * 小明从家里出发，准备去学校后街上网开黑！！！
 * 所有人都到达了网吧，准备开始开黑！！！
 * 小李上着上着饿了，说去次烧烤吗？
 * 小明上着上着饿了，说去次烧烤吗？
 * 小王上着上着饿了，说去次烧烤吗？
 * 大家都同意，一起去次烧烤咯！！！
 * 小明烧烤次完了
 * 小李烧烤次完了
 * 小王烧烤次完了
 * 大家一起回寝室！！！
 */