Java并发编程：CountDownLatch的实战应用

原创红太狼 2024-11-14 01:21 9阅读 0赞

Java并发编程中，`CountDownLatch` 是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。`CountDownLatch`通过一个计数器来实现，该计数器在初始化时被设置为一个特定的值，每当一个任务执行完毕时，计数器的值就会减一，当计数器的值减至零时，那些因调用 `await()` 方法而在 `CountDownLatch` 上等待的线程就会被唤醒。

以下是 `CountDownLatch` 的一些实战应用场景：

###1.等待多个任务完成假设你有一个任务需要等待多个并发任务完成后才能继续执行，可以使用 `CountDownLatch`来实现。

```javapublic class CountDownLatchExample {
 public static void main(String[] args) throws InterruptedException {
int threadCount =3;
CountDownLatch latch = new CountDownLatch(threadCount);

for (int i =0; i < threadCount; i++) {
 new Thread(new Worker(latch)).start();
 }

latch.await(); //等待所有线程完成 System.out.println("所有任务完成");
 }

static class Worker implements Runnable {
 private final CountDownLatch latch;

public Worker(CountDownLatch latch) {
 this.latch = latch;
 }

@Override public void run() {
 try {
//执行任务 System.out.println(Thread.currentThread().getName() + "正在执行任务");
Thread.sleep(1000); //模拟任务执行时间} catch (InterruptedException e) {
e.printStackTrace();
} finally {
 latch.countDown(); //任务完成，计数器减一 }
 }
 }
}
```###2. 初始化资源在应用程序启动时，可能需要加载一些资源或执行一些初始化操作，这些操作需要并行执行以提高效率，但只有当所有初始化操作完成后，应用程序才能继续运行。

```javapublic class ApplicationStartup {
 public static void main(String[] args) throws InterruptedException {
int initTasks =3;
CountDownLatch latch = new CountDownLatch(initTasks);

for (int i =0; i < initTasks; i++) {
 new Thread(new Initializer(latch)).start();
 }

latch.await(); //等待所有初始化任务完成 System.out.println("应用程序启动完成");
 }

static class Initializer implements Runnable {
 private final CountDownLatch latch;

public Initializer(CountDownLatch latch) {
 this.latch = latch;
 }

@Override public void run() {
 try {
//执行初始化任务 System.out.println(Thread.currentThread().getName() + "正在初始化资源");
Thread.sleep(1000); //模拟初始化时间} catch (InterruptedException e) {
e.printStackTrace();
} finally {
 latch.countDown(); // 初始化完成，计数器减一 }
 }
 }
}
```###3.测试并发代码在进行并发代码的测试时，`CountDownLatch`可以用来确保测试代码在所有并发任务执行完毕后再进行验证。

```javapublic class ConcurrencyTest {
 public static void main(String[] args) throws InterruptedException {
int threadCount =10;
CountDownLatch latch = new CountDownLatch(threadCount);

for (int i =0; i < threadCount; i++) {
 new Thread(new TestTask(latch)).start();
 }

latch.await(); //等待所有测试任务完成//进行验证 System.out.println("测试完成");
 }

static class TestTask implements Runnable {
 private final CountDownLatch latch;

public TestTask(CountDownLatch latch) {
 this.latch = latch;
 }

@Override public void run() {
 try {
//执行测试任务 System.out.println(Thread.currentThread().getName() + "正在执行测试任务");
Thread.sleep(500); //模拟测试时间} catch (InterruptedException e) {
e.printStackTrace();
} finally {
 latch.countDown(); //测试任务完成，计数器减一 }
 }
 }
}
````CountDownLatch` 是一个强大的工具，可以帮助你控制并发任务的执行流程，确保在所有任务完成之前，主线程不会继续执行。在使用时，需要注意正确地管理计数器的值，以避免出现程序永远等待的情况。