CountDownLatch 和 CyclicBarrier 在 Java 并发编程中的妙用

2023-10-09 18:19:21

并发编程中的同步利器：CountDownLatch 和 CyclicBarrier

引言

在多线程编程中，线程同步是一个关键的概念。它允许线程协调执行，避免资源竞争和数据不一致。Java 提供了强大的线程同步工具，其中 CountDownLatch 和 CyclicBarrier 尤为突出。在这篇博客中，我们将深入探讨这两个工具，并了解如何利用它们轻松实现复杂的并发任务。

CountDownLatch：协调线程等待

什么是 CountDownLatch？

CountDownLatch 是一个线程同步工具，用于协调多个线程的同步。它可以理解为一个计数器，记录着需要等待的线程数量。每个线程执行完毕后，CountDownLatch 计数器减 1，当计数器为 0 时，所有等待的线程都会被唤醒并继续执行。

使用示例

让我们通过一个示例来理解 CountDownLatch 的工作原理：

// 创建一个 CountDownLatch，计数器初始化为 3
CountDownLatch latch = new CountDownLatch(3);

// 创建 3 个线程
Thread t1 = new Thread(() -> {
    // 等待其他线程执行完毕
    try {
        latch.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("线程 1 执行完毕");
});

Thread t2 = new Thread(() -> {
    // 等待其他线程执行完毕
    try {
        latch.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("线程 2 执行完毕");
});

Thread t3 = new Thread(() -> {
    // 等待其他线程执行完毕
    try {
        latch.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("线程 3 执行完毕");
});

// 启动 3 个线程
t1.start();
t2.start();
t3.start();

// 主线程等待 3 个线程执行完毕
try {
    latch.await();
} catch (InterruptedException e) {
    e.printStackTrace();
}

System.out.println("主线程执行完毕");

在这个示例中，3 个线程同时启动，但它们都必须等待其他线程都执行完毕后才能继续执行。CountDownLatch 通过 countDown() 方法和 await() 方法实现了这种同步。

优点

简单易用
可协调多个线程的等待
可防止线程因资源竞争而阻塞

CyclicBarrier：循环栅栏

什么是 CyclicBarrier？

CyclicBarrier 是另一个线程同步工具，它与 CountDownLatch 的主要区别在于，CyclicBarrier 可以实现多个线程在执行完各自的任务后，同时到达一个屏障点，然后继续执行后续的任务。CyclicBarrier 可以理解为一个循环栅栏，线程必须等待其他线程都到达栅栏后才能继续执行。

使用示例

让我们通过一个示例来理解 CyclicBarrier 的工作原理：

// 创建一个 CyclicBarrier，计数器初始化为 3
CyclicBarrier barrier = new CyclicBarrier(3);

// 创建 3 个线程
Thread t1 = new Thread(() -> {
    System.out.println("线程 1 开始执行");
    try {
        // 等待其他线程执行完毕
        barrier.await();
    } catch (InterruptedException | BrokenBarrierException e) {
        e.printStackTrace();
    }
    System.out.println("线程 1 执行完毕");
});

Thread t2 = new Thread(() -> {
    System.out.println("线程 2 开始执行");
    try {
        // 等待其他线程执行完毕
        barrier.await();
    } catch (InterruptedException | BrokenBarrierException e) {
        e.printStackTrace();
    }
    System.out.println("线程 2 执行完毕");
});

Thread t3 = new Thread(() -> {
    System.out.println("线程 3 开始执行");
    try {
        // 等待其他线程执行完毕
        barrier.await();
    } catch (InterruptedException | BrokenBarrierException e) {
        e.printStackTrace();
    }
    System.out.println("线程 3 执行完毕");
});

// 启动 3 个线程
t1.start();
t2.start();
t3.start();

// 主线程等待 3 个线程执行完毕
try {
    barrier.await();
} catch (InterruptedException | BrokenBarrierException e) {
    e.printStackTrace();
}

System.out.println("主线程执行完毕");