Java并发编程：CountDownLatch和CyclicBarrier实战

原创野性酷女 2024-10-21 20:24 54阅读 0赞

CountDownLatch和CyclicBarrier是Java中两种常用的同步工具，它们分别适用于不同场景的并发控制。

1. CountDownLatch：
- CountDownLatch最初用于一个线程等待一组相关事件发生后，再继续执行。
- 当Countdown计数减少到0时，所有等待的线程会立即被唤醒。

实战例子：
```java
import java.util.concurrent.CountDownLatch;

public class CounterExample {
    public static void main(String[] args) throws InterruptedException {
        // 创建一个 CountDownLatch 计数器，初始值为 10
        CountDownLatch countDownLatch = new CountDownLatch(10);

// 创建10个线程，每个线程执行倒计时任务并唤醒等待的 CountDownLatch
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                try {
                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }));
            thread.start();
        }

// 等待所有线程完成倒计时任务并唤醒 CountDownLatch
        countDownLatch.await();

System.out.println("All threads completed and counted down.");
    }
}
```
2. CyclicBarrier：
- CyclicBarrier最初用于一组线程，当所有线程都通过一个共享的屏障后，所有线程都将阻塞等待这个条件成立。
- 一旦某个线程到达屏障，它会调用 `barrier.await()` 方法来阻塞，直到所有线程都到达屏障。

实战例子：
```java
import java.util.concurrent.CyclicBarrier;

public class BarrierExample {
    public static void main(String[] args) throws InterruptedException {
        // 创建一个 CyclicBarrier 辊子，初始值为 2
        CyclicBarrier barrier = new CyclicBarrier(2);

Thread thread1 = new Thread(() -> {
            try {
                barrier.await();
                System.out.println("Thread 1 reached the barrier.");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }));

Thread thread2 = new Thread(() -> {
            try {
                barrier.await();
                System.out.println("Thread 2 reached the barrier.");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }));

// 启动线程
        thread1.start();
        thread2.start();

// 等待所有线程执行完毕
        thread1.join();
        thread2.join();

System.out.println("All threads completed and joined.");
    }
}
```
总结：
- CountDownLatch主要用于一组相关事件的发生后，等待这些事件的线程会立即被唤醒。
- CyclicBarrier则用于一组线程，当所有线程都到达共享的屏障时，所有线程都会阻塞。

在编写并发代码时，应根据场景选择合适的同步工具。