8_JUC三大辅助类

Posted 2021-10-07 root_zhb

JUC三大辅助类

• 1、CountDownLatch: 减少计数
• 2、CyclicBarrier: 循环栅栏
• 3、Semaphore: 信号灯

总结一句：在并发过程中，到达（减少至或者增加至）或者维持某个条件的前提下，执行相关操作。

1、CountDownLatch: 减少计数

1. CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞
2. 其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)
3. 计数器的值变为0时，因await方法阻塞的线程会被唤醒，继续执行
4. 一般而言，countDown()方法放在finally中

案例：6个同学陆续离开教室后，值班同学才可以关门

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        //定义一个数值为 6 的计数器
        CountDownLatch countDownLatch = new CountDownLatch(6);
        //创建 6 个同学
        for (int i = 1; i <= 6; i++) {
            new Thread(() ->{
                    System.out.println(Thread.currentThread().getName() + "离开了");
                    //计数器减一,不会阻塞
                    countDownLatch.countDown();
            }, "同学" + i).start();
        }
        //主线程 await 休息
        countDownLatch.await();
        //全部离开后自动唤醒主线程
        System.out.println("全部离开了,现在的计数器为" + countDownLatch.getCount());
    }
}

2、CyclicBarrier: 循环栅栏

CyclicBarrier 的构造方法第一个参数是目标障碍数，每执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后的语句。
案例：

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        // public CyclicBarrier(int parties, Runnable barrierAction) {}
        CyclicBarrier cyclicBarrier=new CyclicBarrier(7,()->{
            System.out.println("召唤龙珠");
        });
        for (int i = 1; i <=7; i++) {
            final int temp=i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"\\t收集到了第"+temp+"颗龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

3、Semaphore: 信号灯

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

public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore=new Semaphore(3);
        for (int i = 1; i <=6; i++) {
            new Thread(()->{
                try {
                    System.out.println(Thread.currentThread().getName()+"\\t抢占了车位");
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println(Thread.currentThread().getName()+"\\t离开了车位");
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}