CountDownLatch与CyclicBarrier区别对比

在Java并发编程中，`CountDownLatch`、`CyclicBarrier`和`Semaphore`是三个重要的线程同步工具，但它们的应用场景和解决的问题各不相同。本文将深入探讨`CountDownLatch`与`CyclicBarrier`的区别，以及`Semaphore`的作用。`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() 被调用三次，计数器变为 0。

什么时候应该使用 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 来实现这个限制。

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，则 Semaphore 为公平模式；否则为非公平模式。

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

如何处理 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 异常后，CyclicBarrier 会进入损坏状态，无法再次使用。你需要创建一个新的 CyclicBarrier 对象才能继续使用。

终于介绍完啦！小伙伴们，这篇关于《CountDownLatch与CyclicBarrier区别对比》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布文章相关知识，快来关注吧！