CountDownLatch、CyclicBarrier和Semaphore区别及底层原理

桃扇骨 2023-10-13 15:01 19阅读 0赞

### 1、CountDownLatch ###

表示计数器，可以给CountDownLatch设置一个数字，一个线程调用CountDownLatch的await()将会阻塞，其他线程调用CountDownLatch的countDown()方法来对CountDownLatch中的数字减一，当数字被减成0后，所有的await线程将被唤醒。

对应的底层原理就是，调用await()方法的线程会利用AQS队列，一旦数字被减为0，则会将AQS中正在排队的线程依次唤醒。

CountDownLatch的不足：CountDownLatch是一次性的，计算器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当CountDownLatch使用完毕后，它不能再次被使用。

使用场景：CountDownLatch可以应用于主线程等待所有子线程结束后再继续执行的情况。

public class Main {
        
        public static void main(String[] args) throws InterruptedException {
        
            CountDownLatch countDownLatch = new CountDownLatch(2);
            new Thread(() -> {
        
                for (int i = 0; i < 3; i++) {
        
                    System.out.println(Thread.currentThread().getName() + "->" + i);
                }
                countDownLatch.countDown();
            }).start();
            new Thread(() -> {
        
                for (int i = 0; i < 3; i++) {
        
                    System.out.println(Thread.currentThread().getName() + "->" + i);
                }
                countDownLatch.countDown();
            }).start();
            countDownLatch.await();
            System.out.println("两个子线程都执行完毕，继续执行主线程");
        }
    }

### 2. CyclicBarrier ###

CyclicBarraer可以使一组线程等待,当线程数量够时,一起执行，利用await()阻塞,每次阻塞一个线程并且计数变量减一，当计数变量为0时,将之前阻塞的线程都一起唤醒，当阻塞的线程达到了规定的数量的时候就一起释放。

CountDownLatch是先执行前置的线程,再执行任务线程  
CyclicBarraer是指定一定数量的线程在某一刻一起执行

使用场景：用在所有子线程之间互相等待多次的情形。

public class Main {
        
        static class TaskThread extends Thread {
        
            CyclicBarrier barrier;
    
            public TaskThread(CyclicBarrier barrier) {
        
                this.barrier = barrier;
            }
    
            @Override
            public void run() {
        
                try {
        
                    Thread.sleep(1000);
                    System.out.println(getName() + "比赛准备");
                    barrier.await();
                    System.out.println(getName() + "到达终点");
                } catch (Exception e) {
        
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String[] args) {
        
            int threadNum = 5;
            CyclicBarrier barrier = new CyclicBarrier(threadNum, () -> System.out.println(Thread.currentThread().getName() + "最后一个也准备好了，比赛开始"));
    
            for (int i = 0; i < threadNum; i++) {
        
                new TaskThread(barrier).start();
            }
        }
    
    }

### 3. Semaphore ###

表示信号量，可以设置许可的个数，表示同时允许最多多少个线程使用该信号量，可以控制同时访问的线程个数。通过acquire()来获取许可，如果没有许可可用则线程阻塞并通过AQS来排队，可以通过release()方法来释放许可，当某个线程释放了某个许可后会从AQS中正在排队的第一个线程开始依次唤醒，直到没有空闲许可.

使用场景：流量控制，特别公用资源有限的应用场景，比如数据库连接。

public class Main {
        
        // 小区楼下停车场同时容纳的车辆2
        private static Semaphore semaphore = new Semaphore(2);
    
        public static void main(String[] args) {
        
            // 模拟5辆车进入停车场
            for (int i = 0; i < 5; i++) {
        
                new Thread(() -> {
        
                    try {
        
                        System.out.println(Thread.currentThread().getName() + "来到停车场");
                        if (semaphore.availablePermits() == 0) {
        
                            System.out.println("车位不足，请耐心等待");
                        }
                        // 获取令牌尝试进入停车场
                        semaphore.acquire();
                        System.out.println(Thread.currentThread().getName() + "成功进入停车场");
                        // 模拟车辆在停车场停留的时间
                        Thread.sleep(new Random().nextInt(10000));
                        System.out.println(Thread.currentThread().getName() + "驶出停车场");
                        // 释放令牌，腾出停车场车位
                        semaphore.release();
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }, i + "号车").start();
            }
        }
    }