高并发下的三个常用辅助类（CountDownLatch、CyclicBarrier、Semaphore）

一、CountDownLatch

类似于加法计数器，当达到设置的数值后，根据代码执行相应内容

原理：

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

通俗的说就是设置count=5的话，若在某处写上await等待方法堵塞进程，执行5次CountDown方法后才能恢复进程。

例子：

若一个房子里面有5个人，门是await，每出去一个人就相当于执行CountDown，5个人都出去后，门就可以关闭了。

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        //总数6   必须要执行任务的时候，再使用！
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i=1;i<=6;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" Go out");
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }

        //没有这句的话，就可能会下面先执行，再执行其它线程的
        countDownLatch.await(); //等待计数器归零，然后向下执行

        System.out.println("close door");
    }
}

二、CyclicBarrier

CyclicBarrier也类似于一个减法计数器，设置指定的数值减到0后执行相应的事件。

和CountDownLatch不同的是CyclicBarrier的await方法内部自动减1，也就是调用await方法就执行了减1操作。假设数值设置为5，每个线程调用一次await方法，如果只有4个线程调用了，那么程序不会结束，会等待第五次调用await后，计数值减到0才会继续运行直到结束。

例子：

集齐七颗龙珠才能召唤神龙，少一颗都召唤不了，也不能放弃（程序等待），直到集齐七颗后，执行创建对象CyclicBarrier的时候lambda表达式中的代码操作，程序继续运行。

public class CyclicBarrierDemo {
    //例子：集齐七颗龙珠召唤神龙
    public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
        //可以只传入一个计数参数，也可以在传入达到计数值时的事件
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("召唤神龙成功！");
        });

        for (int i=1;i<=7;i++){
            final int temp = i; //lambda表达式中使用外部变量需要是final
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集"+temp+"个龙珠");
                try {
                    cyclicBarrier.await();  //等待（调用await内部会-1，直到0的时候结束）
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

三、Semaphore

设置一个数值，这个数值相当于一个停车场里面的车位，每次只准这么多的车进来停放，多了就要慢慢等。释放一个资源（有一个车走了，空了一个车位），等待的线程才能使用（等待的车辆有位置停车）。

信号量主要用于两个目的：一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。

原理：

• acquire（获取）

        当一个线程调用 acquire 操作时，他要么通过成功获取信号量（信号量-1）

        要么一直等下去，直到有线程释放信号量，或超时

• release （释放）

        实际上会将信号量的值 + 1，然后唤醒等待的线程。

public class SemaphoreDemo {
    public static void main(String[] args) {
        //线程数量，停车位,限流！
        Semaphore semaphore = new Semaphore(3);  //一次只允许这么多
        String str = "hello";
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                //acquire()得到
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+" 抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+" 离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //release()释放
                    semaphore.release();
                }

            },String.valueOf(i)).start();
        }

    }
}

搜索

复制