JUC高级多线程_06：多线程下得常用辅助类

Posted 2021-06-05 ABin-阿斌

我是 ABin-阿斌：写一生代码，创一世佳话，筑一揽芳华。 如果小伙伴们觉得我的文章有点 feel ，那就点个赞再走哦。

文章目录

• 1 . CountDownLatch（减少计数）
• • • 1. 例子 - 未使用 CountDownLatch
    • 2. 使用 CountDownLatch 后
    • 3. 原理：
• 2 . CyclicBarrier（循环屏障）
• • • 1. 例子
    • 2. 原理：
• 3 . Semaphore（信号灯）
• • • 1. 例子
    • 2. 原理：
    • 3. 启发

1 . CountDownLatch（减少计数）

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

1. 例子 - 未使用 CountDownLatch

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

public class CountDownLatchTest {
    public static void main(String[] args) {
        for (int i = 0; i <= 5; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "同学陆续离开教室");
            }, String.valueOf(i)).start();
        }
        System.out.println(Thread.currentThread().getName() + "班长最后离开教室");
    }
}

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

2. 使用 CountDownLatch 后

public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i <= 5; i++) {
            //总数是6，必须要执行任务的时候，再使用！
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "同学陆续离开教室");
                //每离开一个同学就减=1
                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++){
            // 加 final的作用：加了final后，这个变量会存在堆中的方法区里面。
           // 因为这样我们的一个子进程就可以共享进程的堆了，所以也就能读到这个 i 变量了。
           // 否则存在另一个线程的栈中，不同的线程是读取不到的。
            final int peo = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"已进入会议室的人数："+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()+"已占有该车位");
                    //持有资源一段时间
                    try {
                        TimeUnit.SECONDS.sleep(3);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"已离开该车位");

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

2. 原理：

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

3. 启发

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