Java并发工具：CountDownLatch、CyclicBarrier等实战应用案例

原创左手的ㄟ右手 2024-09-16 22:30 71阅读 0赞

在Java并发编程中，CountDownLatch和CyclicBarrier是两种常用的同步工具。下面我将为你提供这两种工具的实战应用案例。

1. CountDownLatch

应用场景：
- 一个任务需要多个子任务完成后才能执行，这样的场景可以使用CountDownLatch。
- 模拟生产流水线，每个生产环节完成后都会向下游传递信号。

示例代码（简化版）：
```java
import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    private CountDownLatch latch = new CountDownLatch(3);

public void task1() {
        System.out.println("Task 1 started");
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task 1 completed");
        latch.countDown(); // 唤醒CountDownLatch
    }

public void task2() {
        System.out.println("Task 2 started");
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task 2 completed");
        latch.countDown(); // 唤醒CountDownLatch
    }

public void task3() {
        System.out.println("Task 3 started");
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task 3 completed");
        latch.countDown(); // 唤醒CountDownLatch
    }

public static void main(String[] args) {
        CountDownLatchExample example = new CountDownLatchExample();

new Thread(example::task1).start();
        new Thread(example::task2).start();
        new Thread(example::task3).start();

try {
            latch.await(); // 等待CountDownLatch计数为0
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

2. CyclicBarrier

应用场景：
- 当多个线程需要在某一特定时刻汇聚，然后各自独立运行时，可以使用CyclicBarrier。
- 模拟工作轮换，每个线程到达一个共同的点后，将执行下一个任务。

示例代码（简化版）：
```java
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    private CyclicBarrier barrier = new CyclicBarrier(2); // 两个线程

public void task1() throws Exception {
        System.out.println("Task 1 started");
        barrier.await(); // 等待barrier到达所有线程
        System.out.println("Task 1 completed");
    }

public void task2() throws Exception {
        System.out.println("Task 2 started");
        barrier.await(); // 等待barrier到达所有线程
        System.out.println("Task 2 completed");
    }

public static void main(String[] args) {
        CyclicBarrierExample example = new CyclicBarrierExample();

new Thread(example::task1)).start();
        new Thread(example::task2)).start();

// 这里不需要调用await，因为CyclicBarrier在所有线程等待到达后会自动关闭
    }
}
```

以上就是CountDownLatch和CyclicBarrier在Java并发编程中的应用案例。