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

╰半夏微凉° 2023-10-04 14:41 22阅读 0赞

> **我是 ABin-阿斌：写一生代码，创一世佳话，筑一揽芳华。 如果小伙伴们觉得我的文章有点 feel ，那就点个赞再走哦。**  
> ![在这里插入图片描述][01244a35a05f9070bf77418374331efc.png_pic_center]

### 文章目录 ###

*  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() + "班长最后离开教室");
        }
    }

*  **结果：** 会出现班长不是最后一个离开的情况，把其他同学锁在教室里了
 *  ![在这里插入图片描述][beb5b6d2a60f72d53ef084f791f65702.png_pic_center]

### 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** 同步锁

[01244a35a05f9070bf77418374331efc.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/01244a35a05f9070bf77418374331efc.png#pic_center
[beb5b6d2a60f72d53ef084f791f65702.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/beb5b6d2a60f72d53ef084f791f65702.png#pic_center