Java并发工具库：CountDownLatch与CyclicBarrier使用案例

原创电玩女神 2024-09-24 12:21 79阅读 0赞

`CountDownLatch`和`CyclicBarrier`都是Java中用于管理多线程间同步的工具类。以下是一些使用案例：

1. CountDownLatch: 假设有两个线程，一个负责生产任务，另一个负责接收并处理任务。当生产线程完成任务后，通过调用`countDown()`方法来通知等待的消费者线程。

```java
// 生产者线程
class ProducerThread extends Thread {
    private CountDownLatch countDownLatch;

ProducerThread(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

@Override
    public void run() {
        // 生产任务
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println("Producer: Task " + i);
                // 模拟一些耗时的操作
                Thread.sleep(500);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

// 唤醒消费者线程
        countDownLatch.countDown();
    }
}

// 消费者线程
class ConsumerThread extends Thread {
    private CountDownLatch countDownLatch;

ConsumerThread(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

@Override
    public void run() {
        // 模拟接收并处理任务
        try {
            while (!countDownLatch.await(5, TimeUnit.SECONDS), "Timeout")) {
                System.out.println("Consumer: Task received");
                // 处理任务，这里简单模拟一下
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

// 线程停止运行
        System.exit(0);
    }
}

// 使用示例
CountDownLatch countDownLatch = new CountDownLatch(1);
new ProducerThread(countDownLatch).start();
new ConsumerThread(countDownLatch).start();

// 生产者线程完成任务后调用countDown()
countDownLatch.countDown();
```
2. CyclicBarrier: `CyclicBarrier`是当所有等待的线程到达屏障时，才会允许一个线程通过屏障。这对于需要一组相关线程同时完成某个阶段的任务非常有用。

```java
// 使用示例
CyclicBarrier barrier = new CyclicBarrier(3); // 建立屏障，最多允许3个线程通过

new Thread(() -> {
    try {
        barrier.await(); // 等待屏障开启
        System.out.println("Thread 1: Through Barrier");
    } catch (Exception e) {
        e.printStackTrace();
    }
}).start();

// 线程2和3同时到达屏障，屏障开启后允许一个线程通过
new Thread(() -> {
    try {
        barrier.await(); // 等待屏障开启
        System.out.println("Thread 2/3: Through Barrier");
    } catch (Exception e) {
        e.printStackTrace();
    }
}).start();

// 当所有屏障等待的线程到达屏障时，屏障才会开启
```
以上就是`CountDownLatch`和`CyclicBarrier`在Java并发中的使用案例。