Java中的并发编程：CountDownLatch和CyclicBarrier案例

原创悠悠 2024-09-20 19:57 63阅读 0赞

在Java的并发编程中，CountDownLatch和CyclicBarrier是两种常用的同步工具，用于协调多个线程的执行顺序。

1. CountDownLatch

CountDownLatch是一个单向计数对象。当它的初始值为n时（n>0），每个等待该事件的线程都将被阻塞，直到latch的count减到0。

案例：
```java
import java.util.concurrent.CountDownLatch;

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

public void task1() {
        System.out.println("Task 1 starts...");
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task 1 ends...");
    }

public void task2() {
        System.out.println("Task 2 starts...");
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task 2 ends...");
    }

public static void main(String[] args) {
        CountDownLatchExample example = new CountDownLatchExample();
        Thread thread1 = new Thread(example::task1);
        Thread thread2 = new Thread(example::task2);

thread1.start();
        thread2.start();

try {
            // 等待所有线程执行完毕
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```
在这个例子中，我们创建了两个任务（task1和task2），每个任务都会调用CountDownLatch的await()方法来等待count减到0。当所有线程执行完毕后，main方法会调用join()方法让当前线程等待其他线程完成。

2. CyclicBarrier

CyclicBarrier是一个共享屏障，它允许多个线程同时到达一个临界点，但不能保证这些线程会被阻塞在临界点。当一个线程离开这个屏障时，所有后续到达的线程都会被阻塞，直到第一个线程再次通过屏障。

案例：

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

public class CyclicBarrierExample {
    private final CyclicBarrier barrier = new CyclicBarrier(2);

public void task1() throws Exception {
        System.out.println("Task 1 starts...");
        barrier.await(); // 等待屏障
        System.out.println("Task 1 ends...");
    }

public void task2() throws Exception {
        System.out.println("Task 2 starts...");
        barrier.await(); // 等待屏障
        System.out.println("Task 2 ends...");
    }

public static void main(String[] args) {
        CyclicBarrierExample example = new CyclicBarrierExample();
        Thread thread1 = new Thread(example::task1));
        Thread thread2 = new Thread(example::task2));

thread1.start();
        thread2.start();

try {
            // 等待所有线程执行完毕
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```
在这个例子中，我们也创建了两个任务（task1和task2）,每个任务都会调用CyclicBarrier的await()方法来等待屏障。当所有线程执行完毕后，main方法会调用join()方法让当前线程等待其他线程完成。