java多线程：CountDownLatch、CyclicBarrier 和 Semaphore的区别

- 日理万妓 2024-02-20 12:17 73阅读 0赞

> JUC中的同步器三个主要的成员：CountDownLatch、CyclicBarrier和Semaphore，通过它们可以方便地实现很多线程之间协作的功能。

CountDownLatch叫倒计数，允许一个或多个线程等待某些操作完成。  
看几个场景：

*  跑步比赛，裁判需要等到所有的运动员（“其他线程”）都跑到终点（达到目标），才能去算排名和颁奖。
 *  模拟并发，我需要启动100个线程去同时访问某一个地址，我希望它们能同时并发，而不是一个一个的去执行。
 *  用法：CountDownLatch构造方法指明计数数量，被等待线程调用countDown将计数器减1，等待线程使用await进行线程等待。

CyclicBarrier叫循环栅栏，它实现让一组线程等待至某个状态之后再全部同时执行，而且当所有等待线程被释放后，CyclicBarrier可以被重复使用。

*  CyclicBarrier的典型应用场景是用来等待并发线程结束。CyclicBarrier的主要方法是await()，await()每被调用一次，计数便会减少1，并阻塞住当前线程。当计数减至0时，阻塞解除，所有在此CyclicBarrier上面阻塞的线程开始运行。在这之后，如果再次调用await()，计数就又会变成N-1，新一轮重新开始，这便是Cyclic的含义所在。CyclicBarrier.await()带有返回值，用来表示当前线程是第几个到达这个Barrier的线程。

Semaphore，Java版本的信号量实现，用于控制同时访问的线程个数，来达到限制通用资源访问的目的，其原理是通过acquire()获取一个许可，如果没有就等待，而release()释放一个许可。如果Semaphore的数值被初始化为1，那么一个线程就可以通过acquire进入互斥状态，本质上和互斥锁是非常相似的。

但是区别也非常明显，比如互斥锁是有持有者的，而对于Semaphore这种计数器结构，虽然有类似功能，但其实不存在真正意义的持有者，除非我们进行扩展包装。

## 三者区别 ##

CountDownLatch、CyclicBarrier 和 Semaphore 是 Java 并发编程中用于多线程协作的工具类，它们在功能和使用方式上有一些显著区别：

1.  CountDownLatch（倒计时门闩）：
    
     *  功能：CountDownLatch 用于等待一个或多个线程执行完特定操作后再继续执行。
     *  使用方式：主线程调用 `await()` 方法等待计数器归零，而其他线程执行完操作后通过 `countDown()` 方法将计数器减一。
     *  特点：CountDownLatch 是一个一次性的计数器，一旦计数器归零，无法重置。
2.  CyclicBarrier（循环屏障）：
    
     *  功能：CyclicBarrier 用于等待一组线程都到达某个屏障点后再继续执行，可以循环使用。
     *  使用方式：所有线程在执行完特定操作后调用 `await()` 方法等待其他线程到达屏障点，当所有线程都到达后，会执行传入的 `Runnable` 对象中的代码，然后所有线程继续执行。
     *  特点：CyclicBarrier 可以重复使用，每次达到屏障点后，计数器会重置，并且可以执行额外的操作。
3.  Semaphore（信号量）：
    
     *  功能：Semaphore 用于控制同时访问某个资源或执行某个操作的线程数量。
     *  使用方式：线程在执行前尝试获取许可，如果许可数大于 0，则获取许可并执行操作，否则线程会阻塞等待许可的释放，操作完成后释放许可。
     *  特点：Semaphore 维护了一定数量的许可，线程可以获取和释放许可，许可的数量可以根据需要增加或减少。

总结：

*  CountDownLatch 是一次性的计数器，用于等待一个或多个线程完成操作。
 *  CyclicBarrier 是可以循环使用的屏障，用于等待一组线程都到达屏障点后继续执行，并可以执行额外的操作。
 *  Semaphore 是用于控制同时访问资源或执行操作的线程数量，可以增加或减少许可的数量。

## 代码演示 ##

下面是 CountDownLatch、CyclicBarrier 和 Semaphore 的代码示例：

1.  CountDownLatch 示例代码：

import java.util.concurrent.CountDownLatch;
    
    public class CountDownLatchExample {
        
        public static void main(String[] args) throws InterruptedException {
        
            int numberOfThreads = 3;
            CountDownLatch latch = new CountDownLatch(numberOfThreads);
    
            for (int i = 0; i < numberOfThreads; i++) {
        
                Thread thread = new Thread(() -> {
        
                    // 线程执行某些操作
    
                    // 操作完成后调用 countDown()
                    latch.countDown();
                });
                thread.start();
            }
    
            // 主线程等待所有线程完成操作
            latch.await();
    
            System.out.println("All threads have completed their operations.");
        }
    }

在上述代码中，CountDownLatch 的初始计数器值为 `numberOfThreads`，每个线程执行完某些操作后调用 `countDown()` 方法来减少计数器的值。主线程通过调用 `await()` 方法来等待计数器归零，即等待所有线程完成操作。

1.  CyclicBarrier 示例代码：

import java.util.concurrent.BrokenBarrierException;
    import java.util.concurrent.CyclicBarrier;
    
    public class CyclicBarrierExample {
        
        public static void main(String[] args) {
        
            int numberOfThreads = 3;
            CyclicBarrier barrier = new CyclicBarrier(numberOfThreads, () -> {
        
                System.out.println("All threads have reached the barrier.");
            });
    
            for (int i = 0; i < numberOfThreads; i++) {
        
                Thread thread = new Thread(() -> {
        
                    // 线程执行某些操作
    
                    try {
        
                        // 等待其他线程到达屏障点
                        barrier.await();
                    } catch (InterruptedException | BrokenBarrierException e) {
        
                        e.printStackTrace();
                    }
    
                    // 所有线程都到达屏障点后继续执行
                    System.out.println("Thread is continuing after the barrier.");
                });
                thread.start();
            }
        }
    }

在上述代码中，CyclicBarrier 的初始参与线程数为 `numberOfThreads`，每个线程执行完某些操作后调用 `await()` 方法来等待其他线程到达屏障点。当所有线程都到达屏障点时，会执行传入的 `Runnable` 对象中的代码，然后所有线程继续执行。

1.  Semaphore 示例代码：

import java.util.concurrent.Semaphore;
    
    public class SemaphoreExample {
        
        public static void main(String[] args) {
        
            int numberOfPermits = 2;
            Semaphore semaphore = new Semaphore(numberOfPermits);
    
            for (int i = 0; i < 5; i++) {
        
                Thread thread = new Thread(() -> {
        
                    try {
        
                        // 获取许可
                        semaphore.acquire();
                        System.out.println("Thread is executing. Available permits: " + semaphore.availablePermits());
    
                        // 模拟线程执行一段时间
                        Thread.sleep(2000);
    
                        // 释放许可
                        semaphore.release();
                        System.out.println("Thread has completed. Available permits: " + semaphore.availablePermits());
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                });
                thread.start();
            }
        }
    }

在上述代码中，Semaphore 的初始许可数为 `numberOfPermits`，每个线程在执行前先尝试获取许可，如果许可数大于 0，则获取许可并执行操作，否则线程会阻塞等待许可的释放。操作完成后，线程释放许可。Semaphore 可以用来控制同时执行的线程数量。