CountDownLatch, CyclicBarrier, Semaphore 的使用场景与区别

CountDownLatch用于主线程等待其他线程完成操作，CyclicBarrier用于多线程相互等待至屏障点后集体执行，Semaphore用于控制并发访问资源的线程数量。

CountDownLatch, CyclicBarrier, Semaphore 都是并发编程中用于线程同步的工具，但它们的应用场景和解决的问题各不相同。简单来说，CountDownLatch 关注的是“一个或多个线程等待其他线程完成操作”，CyclicBarrier 关注的是“一组线程相互等待至一个屏障点，然后同时执行”，Semaphore 关注的是“控制对共享资源的访问线程数量”。

CountDownLatch, CyclicBarrier, Semaphore 的使用场景与区别

什么时候应该使用 CountDownLatch？

CountDownLatch 主要用于一个或多个线程等待其他线程完成某些操作后才能继续执行的场景。可以想象成一个倒计时器，当计数器减至零时，所有等待的线程将被释放。

举个例子，假设你需要启动一个服务，这个服务依赖于多个组件的初始化。你可以为每个组件创建一个线程，每个线程完成初始化后调用

countDown()

await()

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchExample {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        ExecutorService executor = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 3; i++) {
            final int taskNumber = i + 1;
            executor.execute(() -> {
                try {
                    System.out.println("Task " + taskNumber + " is running...");
                    Thread.sleep((long) (Math.random() * 3000)); // 模拟任务执行时间
                    System.out.println("Task " + taskNumber + " is completed.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown(); // 任务完成后计数器减一
                }
            });
        }

        latch.await(); // 等待所有任务完成
        System.out.println("All tasks are completed. Continuing main thread.");
        executor.shutdown();
    }
}

这个例子模拟了三个任务并行执行，主线程等待所有任务完成后才继续执行。

latch.await()

latch.countDown()

什么时候应该使用 CyclicBarrier？

CyclicBarrier 适用于一组线程相互等待，直到所有线程都到达一个屏障点，然后这些线程才能一起继续执行。与 CountDownLatch 不同，CyclicBarrier 可以重用，即当所有线程到达屏障点后，可以再次等待。

一个典型的应用场景是并行计算，例如图像处理。你可以将图像分成多个部分，每个线程处理一部分。当所有线程都完成处理后，CyclicBarrier 允许它们一起进入下一步，例如合并结果。

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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. Executing barrier action.");
        });

        ExecutorService executor = Executors.newFixedThreadPool(numberOfThreads);

        for (int i = 0; i < numberOfThreads; i++) {
            final int threadNumber = i + 1;
            executor.execute(() -> {
                try {
                    System.out.println("Thread " + threadNumber + " is working...");
                    Thread.sleep((long) (Math.random() * 3000)); // 模拟线程工作时间
                    System.out.println("Thread " + threadNumber + " is waiting at the barrier.");
                    barrier.await(); // 等待其他线程到达屏障
                    System.out.println("Thread " + threadNumber + " is continuing after the barrier.");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
    }
}

这个例子中，三个线程并行工作，每个线程到达

barrier.await()

CyclicBarrier

Runnable

什么时候应该使用 Semaphore？

Semaphore 用于控制同时访问特定资源的线程数量。它维护一个许可集，线程需要获取许可才能访问资源，释放许可后其他线程才能获取。

想象一下一个数据库连接池，你希望限制同时连接数据库的线程数量。你可以使用 Semaphore 来实现这个限制。

10Web

AI驱动的WordPress网站自动构建器，托管和页面速度助推器

下载

import java.util.concurrent.Semaphore;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SemaphoreExample {

    public static void main(String[] args) {
        int numberOfThreads = 5;
        int maxPermits = 2; // 允许同时访问的线程数量
        Semaphore semaphore = new Semaphore(maxPermits);
        ExecutorService executor = Executors.newFixedThreadPool(numberOfThreads);

        for (int i = 0; i < numberOfThreads; i++) {
            final int threadNumber = i + 1;
            executor.execute(() -> {
                try {
                    System.out.println("Thread " + threadNumber + " is trying to acquire a permit.");
                    semaphore.acquire(); // 获取许可
                    System.out.println("Thread " + threadNumber + " has acquired a permit and is accessing the resource.");
                    Thread.sleep((long) (Math.random() * 3000)); // 模拟访问资源
                    System.out.println("Thread " + threadNumber + " is releasing the permit.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release(); // 释放许可
                }
            });
        }

        executor.shutdown();
    }
}

在这个例子中，五个线程尝试访问共享资源，但 Semaphore 限制了同时只能有两个线程访问。线程调用

semaphore.acquire()

CountDownLatch 和 CyclicBarrier 的区别是什么？

CountDownLatch 和 CyclicBarrier 都可以用于线程同步，但它们的设计目标不同。CountDownLatch 是一次性的，计数器只能减一次，而 CyclicBarrier 可以重用。CountDownLatch 主要用于一个或多个线程等待其他线程完成操作，而 CyclicBarrier 主要用于一组线程相互等待。

可以这样理解：CountDownLatch 就像赛跑的终点线，只有到达终点线的线程才能继续前进；CyclicBarrier 就像一个集合点，所有线程必须到达这个点才能一起继续前进。

Semaphore 的公平性如何设置？

Semaphore 可以设置为公平或非公平模式。公平模式下，等待时间最长的线程将优先获得许可。非公平模式下，线程获取许可的顺序是不确定的，可能导致某些线程一直无法获得许可（饥饿）。

在创建 Semaphore 对象时，可以通过构造函数的第二个参数指定公平性：

Semaphore(int permits, boolean fair)

fair

true

公平模式会带来一定的性能开销，因为需要维护等待队列。在并发量不高的情况下，非公平模式可能更有效率。

如何处理 CyclicBarrier 中线程中断的情况？

当 CyclicBarrier 中的一个或多个线程被中断时，会导致

BrokenBarrierException

为了处理这种情况，你可以在

try-catch

BrokenBarrierException

try {
    barrier.await();
} catch (InterruptedException e) {
    // 处理线程中断
    Thread.currentThread().interrupt(); // 重新设置中断标志
} catch (BrokenBarrierException e) {
    // 处理屏障损坏
    System.out.println("Barrier is broken.");
}

需要注意的是，当一个线程抛出

BrokenBarrierException