JUC-多线程（6.JUC三个辅助类）学习笔记

1. CountDownLatch（减少计数）

• 做减法，计数器减为 0 才可以继续

1. 例子 - 使用前

• 班长申请了教室组织自习，来了 6 个同学，这 6 个同学学完自行离开，但是班长必须最后一个离开，并锁上门

public static void main(String[] args) {
        for (int i = 1; i <= 6; i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"\t离开教室");
            },String.valueOf(i)).start();
        }
        System.out.println(Thread.currentThread().getName()+"班长最后离开");
    }

• 结果：会出现班长不是最后一个离开的情况，把其他同学锁在教室里了

2. 使用后

public static void main(String[] args) throws InterruptedException {
// 使用CountDownLatch
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i <= 6; i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"\t离开教室");
                //离开一个同学，计数减一
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }
        // 先阻塞，不让班长离开
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName()+"班长最后离开");
    }

3. 原理

• CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞。
• 其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)，
• 当计数器的值变为0时，因await方法阻塞的线程会被唤醒，继续执行。

2. CyclicBarrier（循环栅栏）

• 做加法，计数器加到规定的数字才可以继续

1. 例子

• 6 个人去会议室开会，只有人齐了才可以开始会议

// 一般使用的构造方法 ： CyclicBarrier(int parties, Runnable barrierAction)
        CyclicBarrier cyclicBarrier = new CyclicBarrier(6,() -> {
            System.out.println("==== 会议开始 ====");
        });


        for (int i = 1; i <= 6; i++){
            // Lambda 表达式中，不能使用局部变量，只能使用 final
            final int peo = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"\t进入会议室,已进入："+peo+"人");
                try {
                    // 阻塞
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }

2. 原理

• CyclicBarrier 的字面意思是可循环（Cyclic）使用的屏障（Barrier）。
• 它要做的事情是，是让一组线程到达一个屏障（也可以叫同步点）时被阻塞，
• 直到最后一个线程到达屏障时，屏障才会开门，所有，被屏障拦截的线程才会继续干活。
• 线程进入屏障通过CyclicBarrier的await()方法。

3. Semaphore（信号灯）

• 类似于抢车位，多辆车，抢多个车位，车位满就等，一空出来就继续抢

1. 例子

• 6 辆车，抢 3 个车位

Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <= 6; i++){
            new Thread(()->{
                try {
                    //抢占资源，资源数自动减一
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"\t抢到车位+++++");
                    //持有资源一段时间
                    try {
                        TimeUnit.SECONDS.sleep(3);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"\t离开车位---");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //释放持有的资源
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }

2. 原理

• 在信号量上我们定义两种操作：
• acquire（获取） 当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），
  -没有抢到资源的一直等下去，直到有线程释放信号量，或超时。
• release（释放）实际上会将信号量的值加1，然后唤醒等待的线程。
• 信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。

3. 启发

• 当把资源数变为 1 ，就等同于 synchronized 同步锁