Java并发工具：CountDownLatch和CyclicBarrier实例解析

原创 ╰+哭是因爲堅強的太久メ 2024-11-09 13:18 32阅读 0赞

Java并发编程中，`CountDownLatch`和`CyclicBarrier`是两个常用的同步辅助类，它们都可以用来协调多个线程之间的操作。下面我将分别解释这两个工具，并给出实例解析。

### CountDownLatch`CountDownLatch`是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

**特点：**
- `CountDownLatch`的计数器不能被重置。
-只有当计数器的值到达0时，等待的线程才会被释放。

**实例解析：**

假设我们有一个任务，需要等待三个线程完成各自的任务后，主线程才继续执行。

```javaimport java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
 public static void main(String[] args) throws InterruptedException {
 final int threadCount =3;
CountDownLatch latch = new CountDownLatch(threadCount);

for (int i =0; i < threadCount; i++) {
 new Thread(new Worker(latch)).start();
 }

latch.await(); //等待所有线程完成 System.out.println("所有任务完成，主线程继续执行");
 }

static class Worker implements Runnable {
 private final CountDownLatch latch;

public Worker(CountDownLatch latch) {
 this.latch = latch;
 }

@Override public void run() {
 try {
//模拟任务执行 System.out.println(Thread.currentThread().getName() + "正在执行任务");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
 latch.countDown(); //任务完成，计数器减1 }
 }
 }
}
```### CyclicBarrier`CyclicBarrier`是一个同步辅助类，它允许一组线程互相等待，直到所有线程都到达某个公共屏障点（barrier point）。

**特点：**
- `CyclicBarrier`的计数器可以被重置，因此可以重复使用。
-所有线程到达屏障点后，可以选择执行一个任务，然后重置屏障，以便下一次使用。

**实例解析：**

假设我们有五个线程，它们需要在开始执行任务前互相等待。

```javaimport java.util.concurrent.CyclicBarrier;
import java.util.concurrent.BrokenBarrierException;

public class CyclicBarrierExample {
 public static void main(String[] args) {
 final int threadCount =5;
CyclicBarrier barrier = new CyclicBarrier(threadCount, new Runnable() {
@Override public void run() {
 System.out.println("所有线程已到达屏障点，可以开始执行任务");
 }
 });

for (int i =0; i < threadCount; i++) {
 new Thread(new Worker(barrier)).start();
 }
 }

static class Worker implements Runnable {
 private final CyclicBarrier barrier;

public Worker(CyclicBarrier barrier) {
 this.barrier = barrier;
 }

@Override public void run() {
 try {
//模拟任务执行 System.out.println(Thread.currentThread().getName() + "正在执行任务");
Thread.sleep(1000);
 barrier.await(); //等待其他线程到达屏障点} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
 }
 }
 }
}
```在这两个例子中，`CountDownLatch`适用于一次性的等待场景，而`CyclicBarrier`适用于需要多次等待的场景。根据实际需求选择合适的并发工具。