Java中CountDownLatch的生活举例

CountDownLatch是Java中的一个并发工具类，它可以用于控制多个线程的并发执行流程。它的工作原理是，一个线程等待其他线程完成某个任务后再继续执行。

下面是一个生活中的例子来说明CountDownLatch的用法：

假设有一个家庭聚餐，家庭成员需要等待所有人都到齐后才能开始吃饭。这个场景可以使用CountDownLatch来实现。

首先，我们创建一个CountDownLatch对象，设置初始计数器为家庭成员的人数减1（因为主线程也要等待）。

CountDownLatch latch = new CountDownLatch(familyMembers - 1);

然后，每个家庭成员到达聚餐地点后，调用CountDownLatch的countDown()方法来减少计数器的值。

latch.countDown();

最后，主线程调用CountDownLatch的await()方法来等待计数器变为0，表示所有家庭成员都到齐了。

latch.await();

当计数器变为0时，主线程就可以继续执行后面的代码，即开始吃饭。

这样，通过CountDownLatch，我们可以实现多个线程的并发流程控制，确保某个任务在其他线程完成后再执行。

相关问题

java中CountDownLatch使用

CountDownLatch 是一个同步工具类，在多线程环境中常常用于控制线程的执行顺序或者等待某个事件的发生。它的主要作用是让一组线程等待某个事件的发生，当事件发生后，所有等待的线程都可以继续执行。

CountDownLatch 的使用步骤如下：

1. 创建一个 CountDownLatch 对象，指定需要等待的线程数。

2. 在需要等待的线程中，调用 CountDownLatch 的 await() 方法，等待事件的发生。

3. 当事件发生时，调用 CountDownLatch 的 countDown() 方法，通知等待的线程可以继续执行。

下面是一个简单的例子：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {

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

        Thread t1 = new Thread(new Task("Task1", latch));
        Thread t2 = new Thread(new Task("Task2", latch));
        Thread t3 = new Thread(new Task("Task3", latch));

        t1.start();
        t2.start();
        t3.start();

        latch.await(); // 等待所有任务执行完成

        System.out.println("All tasks have been completed.");
    }

    static class Task implements Runnable {
        private String name;
        private CountDownLatch latch;

        public Task(String name, CountDownLatch latch) {
            this.name = name;
            this.latch = latch;
        }

        @Override
        public void run() {
            System.out.println(name + " is running...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + " has completed.");
            latch.countDown();
        }
    }
}

在这个例子中，我们创建了一个 CountDownLatch 对象，并指定需要等待的线程数为 3。然后创建了 3 个线程，并让它们执行一个简单的任务：输出线程名字、等待 1 秒钟，然后输出线程名字并调用 countDown() 方法。最后在主线程中调用 await() 方法等待所有任务执行完成。当所有任务执行完成后，输出一条“所有任务已完成”的消息。

Java中CountDownLatch工具类代码理解

CountDownLatch是Java中一个非常有用的同步工具类，它可以让一个或多个线程等待其他线程完成它们的操作后再执行。在Java中，CountDownLatch类是通过一个计数器来实现的，计数器的初始值可以设置为任何整数。当某个线程调用CountDownLatch的await()方法时，它会阻塞等待计数器的值变为0；而其他线程执行完它们的操作后会通过调用CountDownLatch的countDown()方法来减少计数器的值。当计数器的值变为0时，await()方法将返回，线程得以继续执行。

下面是一个使用CountDownLatch的示例代码：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {

    public static void main(String[] args) throws InterruptedException {
        int numThreads = 5;
        CountDownLatch latch = new CountDownLatch(numThreads);

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

        latch.await();
        System.out.println("All threads have finished!");
    }

    static class Worker implements Runnable {
        private int id;
        private CountDownLatch latch;

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

        public void run() {
            System.out.println("Worker " + id + " is working...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Worker " + id + " has finished.");
            latch.countDown();
        }
    }
}

在这个例子中，我们创建了5个线程，并用CountDownLatch来等待它们全部执行完毕。每个线程都会休眠1秒钟，然后调用countDown()方法来减少计数器的值，最终当所有线程都执行完毕时，await()方法返回，打印出"All threads have finished!"。