在 Java 中使用 CountDownLatch：深入探讨代码示例和演示

深入理解java中的countdownlatch：高效线程同步利器

CountDownLatch是Java java.util.concurrent包中的一个同步辅助类，用于协调多个线程，使其等待直到其他线程完成一组操作。它通过一个计数器实现，初始值设定为需要等待的线程数。每个线程完成任务后，计数器减一。当计数器减为零时，所有等待的线程将被释放。

CountDownLatch是一个同步工具，允许一个或多个线程阻塞，直到其他线程完成一组任务。例如，在启动一个应用程序之前，需要启动多个服务，可以使用CountDownLatch确保主线程等待所有服务启动完毕后再继续执行。

立即学习“Java免费学习笔记（深入）”；

CountDownLatch的核心是一个计数器，初始化时设置为一个正整数。当线程完成任务时，调用countDown()方法，计数器减一。当计数器变为零时，所有调用await()方法的线程将被唤醒。

CountDownLatch在需要线程同步的场景中非常实用。以下是几个关键应用场景：

当多个线程需要互相等待，同时启动时，CountDownLatch是理想选择。例如，同时启动多个服务，并确保它们协同工作。

import java.util.concurrent.CountDownLatch;

public class Service implements Runnable {
    private final CountDownLatch latch;

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

    @Override
    public void run() {
        try {
            System.out.println("Service " + Thread.currentThread().getName() + " is starting...");
            Thread.sleep(2000); // 模拟服务初始化
            latch.countDown(); // 计数器减一
            System.out.println("Service " + Thread.currentThread().getName() + " has started.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Application {
    public static void main(String[] args) throws InterruptedException {
        int numberOfServices = 3;
        CountDownLatch latch = new CountDownLatch(numberOfServices);

        for (int i = 0; i < numberOfServices; i++) {
            new Thread(new Service(latch), "Thread-" + i).start();
        }

        latch.await(); // 等待所有服务启动
        System.out.println("All services are up, application is starting now...");
    }
}

输出示例: (顺序可能略有不同)

Service Thread-0 is starting...
Service Thread-1 is starting...
Service Thread-2 is starting...
Service Thread-0 has started.
Service Thread-1 has started.
Service Thread-2 has started.
All services are up, application is starting now...

一个大型任务可以分解成多个小的子任务并行执行。CountDownLatch可以确保主线程等待所有子任务完成后再继续执行后续操作。

CountDownLatch常用于多阶段任务，每个阶段需要多个线程完成才能进入下一阶段。

import java.util.concurrent.CountDownLatch;

public class PhaseTask implements Runnable {
    private final CountDownLatch latch;
    private final int phase;

    public PhaseTask(CountDownLatch latch, int phase) {
        this.latch = latch;
        this.phase = phase;
    }

    @Override
    public void run() {
        try {
            System.out.println("Thread " + Thread.currentThread().getName() + " is working on phase " + phase);
            Thread.sleep(1000); // 模拟任务执行
            latch.countDown();
            System.out.println("Thread " + Thread.currentThread().getName() + " completed phase " + phase);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class MultiPhaseApplication {
    public static void main(String[] args) throws InterruptedException {
        int phases = 3;
        int threadsPerPhase = 5;

        for (int phase = 1; phase <= phases; phase++) {
            CountDownLatch latch = new CountDownLatch(threadsPerPhase);
            for (int i = 0; i < threadsPerPhase; i++) {
                new Thread(new PhaseTask(latch, phase), "Thread-" + i).start();
            }
            latch.await();
            System.out.println("Phase " + phase + " completed. Moving to next phase...");
        }
        System.out.println("All phases are completed.");
    }
}

输出示例: (顺序可能略有不同)

Thread Thread-0 is working on phase 1
...
Phase 1 completed. Moving to next phase...
...
All phases are completed.

• 简洁性: CountDownLatch提供了一种简单的线程同步机制。
• 可重用性: 适用于多种场景，从等待服务启动到复杂的多阶段任务协调。
• 可靠性: 清晰的生命周期和操作，最大程度降低并发错误风险。

CountDownLatch是Java并发编程中一个强大的工具，能够有效协调多个线程，简化代码并提高可靠性。无论是管理服务启动、任务分解还是多阶段任务同步，CountDownLatch都是一个理想的选择。

进一步学习: 可以搜索 "Java CountDownLatch 代码示例" 获取更多实践案例。

以上就是在 Java 中使用 CountDownLatch：深入探讨代码示例和演示的详细内容，更多请关注图灵教育其它相关文章！