并发编程---常⽤辅助类(四)

素颜马尾好姑娘i 2023-09-24 23:09 54阅读 0赞

### 常⽤辅助类 ###

*  一 CountDownLatch（倒计时⻔闩）
 *   *  案例
     *  结果
     *  当注释await()时观察结果
 *  二CyclicBarrier（篱栅）
 *   *  使用场景
     *  案例代码
     *  结果
 *  三 Semaphore（信号灯）
 *   *  使用场景
     *  案例代码
     *  结果

在高并发的情况下通常会用到一下线程安全的辅助类

![在这里插入图片描述][d5201a8cfbd64ff3810b2dce5144bdcc.png]

# 一 CountDownLatch（倒计时⻔闩） #

CountDownLatch 内部维护了⼀个**计数器**，只有当**计数器==0**时，某些线程才会停⽌阻塞，开始执⾏。  
![在这里插入图片描述][9edbd1763c5f4a03b82372acb7c893a9.png]  
`CountDownLatch` 主要有两个⽅法:

> `countDown()` 来让计数器-1，  
> ![在这里插入图片描述][7cb0892929484eb88c176eaf5f84d144.png]  
> `await()` 来让线程阻塞。  
> ![在这里插入图片描述][d15a0c1a028e4431baa7d5c53405e736.png]  
> 当 count==0 时，阻塞线程⾃动唤醒。

## 案例 ##

班⻓关⻔：main线程是班⻓，6个线程是学⽣。只有6个线程运⾏完毕，都离开教室后，main线程班⻓才会关教室⻔。  
关于 `CountDownLatch` 的使⽤，请看`CountDownLatchDemo`。

/**
     * CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞。
     * 其他线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)，
     * 当计数器的值变为0时，因await方法阻塞的线程会被唤醒，继续执行
     *
     * 案例 班长关门：main线程是班长，6个线程是学生。只有6个线程运行完毕，都离开教室后，main线程班长才会关教室门。
     */
    public class CountDownLatchDemo {
        
        public static void main(String[] args) throws InterruptedException {
        
            //假如是秒杀商品，这个数字应该上商品的数量
            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();
            }
            //当计数器的值变为0时，因await方法阻塞的线程会被唤醒，继续执行
            countDownLatch.await();
            //要把商品的状态改成不可售的状态
            System.out.println(Thread.currentThread().getName()+"\t班长最后关门走人");
    
        }
    }

## 结果 ##

![在这里插入图片描述][d1d34bce5bd54343bcbdb4852cf780fb.png]

## 当注释await()时观察结果 ##

![在这里插入图片描述][8eb511be791e47fa80c8d2f2406697c7.png]

# 二CyclicBarrier（篱栅） #

`CountDownLatch` 是减，⽽ `CyclicBarrier` 是加，理解了 `CountDownLatch` ， `CyclicBarrier` 就很容易。⽐如召集7颗⻰珠才能召唤神⻰，详⻅CyclicBarrierDemo。

## 使用场景 ##

旅行社拼团，满7个人才能开团

## 案例代码 ##

/**
     * `CountDownLatch`是减，而`CyclicBarrier`是加，理解了`CountDownLatch`，`CyclicBarrier`就很容易。
     *
     * 比如召集7颗龙珠才能召唤神龙
     */
    public class CyclicBarrierDemo {
        
        public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
        
    
            //当资源达到了7个之后执行后面的方法
            CyclicBarrier cyclicBarrier = new CyclicBarrier(7, getRunnable());
    
            for (int i = 1; i <= 7; i++) {
        
                final int tempInt = i;
                new Thread(()->{
        
                    System.out.println(Thread.currentThread().getName() + "\t收集到第" + tempInt + "颗龙珠");
    
                    try {
        
                        //当计数器的值变为7时，因await方法阻塞的线程会被唤醒，继续执行
                        cyclicBarrier.await();
                    } catch (Exception e) {
        
                        e.printStackTrace();
                    }
                }, String.valueOf(i)).start();
            }
        }
    
        private static Runnable getRunnable() {
        
            return ()->{
        
                System.out.println("======召唤神龙");
            };
        }
    }

## 结果 ##

![在这里插入图片描述][79c412cc1112402da8b01b09d1209466.png]

# 三 Semaphore（信号灯） #

`CountDownLatch` 的问题是**不能复⽤**。⽐如 count=3 ，那么加到3，就不能继续操作了。⽽ `Semaphore` 可以解决这个问题，⽐如6辆⻋3个停⻋位，对于 `CountDownLatch` 只能停3辆⻋，⽽ `Semaphore` 可以停6辆⻋，⻋位空出来后，其它⻋可以占有，这就涉及到了`Semaphore.accquire()` 和 `Semaphore.release()` ⽅法。

## 使用场景 ##

比如客服操作，一共就几个电话客服，多个人打电话但是客服数量有限，只能等客服解决完一个人的问题才能够帮下一个人解决问题。

## 案例代码 ##

/**
     * 在信号量上我们定义两种操作：
     * acquire（获取）当一个线程调用acquire操作时，他要么通过成功获取信号量（信号量减1），要么一直等待下去，直到有线程释放信号量，或超时。
     * release（释放）实际上会将信号量加1，然后唤醒等待的线程。
     *
     * 信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制
     */
    public class SemaphoreDemo {
        
        public static void main(String[] args) {
        
            //模拟资源类，有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停车3秒后离开车位");
                    } catch (Exception e) {
        
                        e.printStackTrace();
                    } finally {
        
                        //释放资源
                        semaphore.release();
                    }
                }, String.valueOf(i)).start();
            }
        }
    }

## 结果 ##

1	抢到车位
    3	抢到车位
    2	抢到车位
    3	停车3秒后离开车位
    1	停车3秒后离开车位
    2	停车3秒后离开车位
    6	抢到车位
    4	抢到车位
    5	抢到车位
    4	停车3秒后离开车位
    5	停车3秒后离开车位
    6	停车3秒后离开车位

[d5201a8cfbd64ff3810b2dce5144bdcc.png]: https://img-blog.csdnimg.cn/d5201a8cfbd64ff3810b2dce5144bdcc.png
[9edbd1763c5f4a03b82372acb7c893a9.png]: https://img-blog.csdnimg.cn/9edbd1763c5f4a03b82372acb7c893a9.png
[7cb0892929484eb88c176eaf5f84d144.png]: https://img-blog.csdnimg.cn/7cb0892929484eb88c176eaf5f84d144.png
[d15a0c1a028e4431baa7d5c53405e736.png]: https://img-blog.csdnimg.cn/d15a0c1a028e4431baa7d5c53405e736.png
[d1d34bce5bd54343bcbdb4852cf780fb.png]: https://img-blog.csdnimg.cn/d1d34bce5bd54343bcbdb4852cf780fb.png
[8eb511be791e47fa80c8d2f2406697c7.png]: https://img-blog.csdnimg.cn/8eb511be791e47fa80c8d2f2406697c7.png
[79c412cc1112402da8b01b09d1209466.png]: https://img-blog.csdnimg.cn/79c412cc1112402da8b01b09d1209466.png