Java并发工具库：CountDownLatch、CyclicBarrier等的实战示例

原创缺乏、安全感 2024-11-25 02:12 12阅读 0赞

Java的并发工具库，如CountDownLatch和CyclicBarrier，主要用于协调多个线程的执行。以下是这两种工具的实际使用示例：

1. CountDownLatch

CountDownLatch最初是用来模拟一个资源，比如门或锁。当一个线程获取资源（调用countDown()）后，其他线程必须等待资源可用（调用countUp()）才能继续执行。

示例代码：
```java
import java.util.concurrent.CountDownLatch;

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

public void thread1() throws InterruptedException {
        System.out.println("Thread 1 starting...");
        countDownLatch.countDown();
        System.out.println("Thread 1 completed.");
    }

public void thread2() throws InterruptedException {
        System.out.println("Thread 2 starting...");
        countDownLatch.await();
        System.out.println("Thread 2 completed.");
    }

public static void main(String[] args) throws InterruptedException {
        CountDownLatchExample example = new CountDownLatchExample();
        new Thread(example::thread1).start();
        new Thread(example::thread2)).start();
    }
}
```
上述代码中，线程1（thread1()）和线程2（thread2()）同时执行。当线程1调用countDown()时，countDownLatch的值减一。所有等待countDownLatch.countDown()的线程（这里只有线程2）都会继续执行。

2. CyclicBarrier

CyclicBarrier类似于一个终点或屏障，所有到达该屏障的线程都将阻塞，直到最后一个线程通过屏障。

示例代码：
```java
import java.util.concurrent.CyclicBarrier;

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

public void thread1() throws InterruptedException {
        System.out.println("Thread 1 starting...");
        barrier.await(); // 等待屏障，所有到达的线程都将阻塞
        System.out.println("Thread 1 completed.");
    }

public void thread2() throws InterruptedException {
        System.out.println("Thread 2 starting...");
        barrier.await(); // 等待屏障，所有到达的线程都将阻塞
        System.out.println("Thread 2 completed.");
    }

public static void main(String[] args) throws InterruptedException {
        CyclicBarrierExample example = new CyclicBarrierExample();
        new Thread(example::thread1)).start();
        new Thread(example::thread2)).start();
    }
}
```
上述代码中，线程1（thread1()）和线程2（thread2()）同时执行。当线程1和线程2调用barrier.await()时，它们会阻塞，直到屏障被所有到达的线程通过（即所有线程都在barrier.step()后执行过）。