Java并发编程：CountDownLatch和CyclicBarrier的使用场景实例

原创分手后的思念是犯贱 2024-10-22 08:42 25阅读 0赞

在Java并发编程中，CountDownLatch和CyclicBarrier都是用来协调多个线程的工具。它们的应用场景主要是在任务完成后需要等待所有线程完成特定操作的场合。

1. CountDownLatch：
- 使用场景：当一个或多个线程执行完任务后，会通过调用 decrement 方法来通知其他线程可以继续执行了。
- 实例代码（使用Java 8）：
```java
import java.util.concurrent.CountDownLatch;

public class CountdownExample {
    private static final int THREAD_COUNT = 5;
    private static CountDownLatch countDownLatch = new CountDownLatch(THREAD_COUNT);

public static void main(String[] args) {
        // 创建线程，每个线程执行任务并通知CountDownLatch
        for (int i = 0; i < THREAD_COUNT; i++) {
            Thread thread = new Thread(() -> executeTask(i, countDownLatch)));
            thread.start();
        }

// 等待所有线程完成任务后，调用decrement方法
        try {
            countDownLatch.await();
            System.out.println("All tasks completed successfully!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

private static void executeTask(int index, CountDownLatch countDownLatch) {
        // 模拟耗时任务
        try {
            Thread.sleep(1000); // 1秒的延迟，模拟实际耗时
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("Thread " + index + " completed task with delay.");
        countDownLatch.countDown(); // 调用decrement方法，通知其他线程可以继续执行了
    }
}
```

2. CyclicBarrier：
- 使用场景：当多个线程需要共同完成一个阶段任务时，可以使用CyclicBarrier。当所有线程都到达同一个屏障点时，屏障会打开，允许后续的线程继续执行。
- 实例代码（使用Java 8）：
```java
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    private static final int THREAD_COUNT = 5;
    private static final CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT);

public static void main(String[] args) {
        // 创建线程，每个线程执行任务并到达屏障点
        for (int i = 0; i < THREAD_COUNT; i++) {
            Thread thread = new Thread(() -> executeTask(i, barrier)));
            thread.start();
        }

// 等待所有线程都到达屏障点
        try {
            barrier.await(); // 调用await方法，等待屏障打开
            System.out.println("All threads reached the cyclic barrier point.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

private static void executeTask(int index, CyclicBarrier barrier) {
        // 模拟耗时任务
        try {
            Thread.sleep(1000); // 1秒的延迟，模拟实际耗时
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("Thread " + index + " completed task with delay.");
        barrier.wait(); // 调用wait方法，等待屏障打开
    }
}
```

以上就是CountDownLatch和CyclicBarrier在Java并发编程中的使用场景和实例代码。