Java并发工具：CountDownLatch和CyclicBarrier的实战案例

原创男娘i 2024-12-13 02:00 0阅读 0赞

在Java中，CountDownLatch和CyclicBarrier都是用于控制线程等待的工具。下面我们将通过两个实际的案例来理解和使用这两个工具。

### 1. CountDownLatch实战案例

**场景描述**：
假设我们有一个生产任务系统，多个工作线程负责生产任务。当所有任务完成后，主线程会通知所有等待的工作线程开始下一步操作。

**代码实现**：
```java
import java.util.concurrent.CountDownLatch;

public class ProductTaskSystem {
    private final CountDownLatch taskCompletedSignal = new CountDownLatch(1);

// 工作线程
    public void workerThread() {
        // 生产任务逻辑
        produceTask();
        
        // 任务完成后通知主线程
        taskCompletedSignal.countDown();
    }

// 主线程
    public void mainThread() {
        // 创建并启动多个工作线程
        for (int i = 0; i < 10; i++) {
            new Thread(() -> workerThread())).start();
        }

// 当所有任务完成后，主线程通知完成信号
        try {
            taskCompletedSignal.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // 开始下一步操作
        System.out.println("All tasks completed. Starting next step.");
    }

// 生产任务逻辑
    private void produceTask() {
        // 任务生产逻辑，例如：模拟网络请求等
        try {
            Thread.sleep(500); // 模拟耗时
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Task produced. Checking completion signal.");
    }
}
```

**输出结果**：
当所有工作线程完成任务后，主线程会调用`await()`方法等待信号释放。在示例中，程序将输出以下信息：

```text
All tasks completed. Starting next step.
Task produced. Checking completion signal.
```

### 2. CyclicBarrier实战案例

**场景描述**：
假设我们有一个汽车制造生产线，每个工作线程代表一个生产单元。当所有单元完成生产后，整个生产线将关闭。

**代码实现**：
```java
import java.util.concurrent.CyclicBarrier;

public class CarManufacturingLine {
    private final CyclicBarrier barrier = new CyclicBarrier(2); // 两个生产单元

// 工作线程
    public void workerThread() {
        try {
            // 模拟生产逻辑，每个工作线程代表一个生产单元
            System.out.println("Worker thread " + Thread.currentThread().getName() + " is starting production.");
            barrier.await(); // 等待其他单元完成生产

// 生产完成后，通知下一个单元开始生产
            System.out.println("Worker thread " + Thread.currentThread().getName() + " has finished production. Starting next unit.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

// 主线程
    public void mainThread() {
        // 创建并启动多个工作线程
        for (int i = 0; i < 5; i++) {
            new Thread(() -> workerThread())).start();
        }

// 当所有单元完成生产后，主线程通知关闭信号
        barrier.countDown(); // 告知所有等待的线程可以开始下一轮循环

System.out.println("Main thread has received signal to close the line. Production is over.");
    }
}
```

**输出结果**：
当所有工作线程完成生产后，程序将输出以下信息：

```text
Worker thread WorkerThread-1 is starting production.
Worker thread WorkerThread-2 is starting production.
Worker thread WorkerThread-3 is starting production.
Worker thread WorkerThread-4 is starting production.
Worker thread WorkerThread-3 has finished production. Starting next unit.
Worker thread WorkerThread-2 has finished production. Starting next unit.
Worker thread WorkerThread-1 has finished production. Starting next unit.
Main thread has received signal to close the line. Production is over.
```

以上就是CountDownLatch和CyclicBarrier在Java并发工具中的实战案例。