CountDownLatch、CyclicBarrier、Semaphore三大常用类详解

CountDownLatch

类似于一个减法计数器：
CountDownLatch(int count) 构造方法初始一个计数值

public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6); //计数值为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(); // 必须等待计数值为0才能往下执行
        System.out.println("结束");
    }
}

结果：

1-> Go out
6-> Go out
5-> Go out
3-> Go out
4-> Go out
2-> Go out
结束

countDownLatch.await() 使当前线程堵塞，必须等待countDownLatch的计数值为0才会被唤醒往下执行

CyclicBarrier

类似于一个加法计数器：

public class CyclicBarrierTest {
    public static void main(String[] args) {
        // 计数值默认从0开始
        CyclicBarrier cyclicBarrier = new CyclicBarrier(6,()->{
            System.out.println("结束");
        });
        for (int i=1;i<=6;i++){
            final int temp = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"->"+temp);
                try {
                    cyclicBarrier.await(); // await()执行后当前线程堵塞，同时计数值加一，当计数值为6才执行后面的
                    System.out.println(temp);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

结果：

1->1
6->6
5->5
3->3
4->4
2->2
结束
2
5
1
4
3
6

countDownLatch.await() 使当前线程堵塞，同时计数值加一，必须等待countDownLatch的计数值达到要求才会被唤醒往下执行

Semaphore

信号量机制：

public class SemaphoreTest {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3); // 信号量，最多允许3个线程同时进行
        for (int i = 1; i <=6 ; i++) {
            new Thread(()->{
                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 {
                    semaphore.release(); // 释放许可证，将其返回信号量
                }
            },String.valueOf(i)).start();
        }
    }
}

结果：

1正在运行...
2正在运行...
3正在运行...
1停止运行...
4正在运行...
2停止运行...
3停止运行...
6正在运行...
5正在运行...
4停止运行...
5停止运行...
6停止运行...

semaphore.acquire()获得许可，信号量减一
semaphore.release()释放许可，信号量加一
当信号量为0时，其他线程堵塞，等待有信号量释放时再被唤醒