Java并发编程同步器CountDownLatch

下面详细讲解“Java并发编程同步器CountDownLatch”的完整攻略。

什么是CountDownLatch？

CountDownLatch是Java并发编程中的一种同步器，用于线程之间的协调和同步。通常，我们需要在某一个线程中等待其他多个线程都执行完毕之后再执行，这个时候就可以使用CountDownLatch来实现。

CountDownLatch的构造函数

CountDownLatch的构造函数如下：

public CountDownLatch(int count) { }; // count为计数器初始值

其中，count表示计数器的初始值，表示需要等待的线程数。

CountDownLatch的常用方法

CountDownLatch的常用方法有两个，分别是：

• await() ：等待计数器归零，也就是等待其他线程执行完成。
• countDown() ：计数器减1。

计数器的初始值是在构造函数中指定的，每调用一次countDown()方法计数器就会减1，当计数器的值减少到0时，表示所有需要等待的线程都执行完成了，await()方法就会返回，继续执行。

CountDownLatch的示例

下面，我们通过两个示例来详细说明CountDownLatch的使用方法。

示例1：统计多个线程执行的时间

在这个示例中，我们需要统计多个线程执行的时间，并在所有的线程都执行完成后输出统计结果。

public class CountDownLatchDemo {

    public static void main(String[] args) {
        int threadNum = 5;
        CountDownLatch countDownLatch = new CountDownLatch(threadNum);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < threadNum; i++) {
            new SubThread(countDownLatch).start();
        }

        try {
            // 等待所有子线程执行完成
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("所有线程执行完成，总耗时：" + (endTime - startTime) + "ms");
    }

    static class SubThread extends Thread {
        private CountDownLatch countDownLatch;

        public SubThread(CountDownLatch countDownLatch) {
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void run() {
            String threadName = Thread.currentThread().getName();
            System.out.println("线程" + threadName + "开始执行...");
            // 模拟线程执行
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程" + threadName + "执行完成。");
            countDownLatch.countDown();
        }
    }
}

首先，我们创建一个CountDownLatch实例，并将需要等待的子线程数量赋值给它。然后，启动多个子线程，每个子线程需要在执行完成之后调用countDown()方法。在主线程中，我们调用await()方法等待所有子线程执行完成，统计总耗时并输出。

示例2：模拟多个工人修桥

在这个示例中，我们模拟多个工人修桥，只有所有工人的工作都完成之后，修桥的任务才能算完成。

public class CountDownLatchDemo {

    public static void main(String[] args) {
        int workerNum = 5;
        CountDownLatch countDownLatch = new CountDownLatch(workerNum);
        System.out.println("需要修桥，有" + workerNum + "个工人来干活");
        for (int i = 0; i < workerNum; i++) {
            new Worker(countDownLatch, "worker-" + i).start();
        }

        try {
            // 等待所有工人完成工作
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("所有工人工作完成，桥修好了。");
    }

    static class Worker extends Thread {
        private CountDownLatch countDownLatch;
        private String name;

        public Worker(CountDownLatch countDownLatch, String name) {
            this.countDownLatch = countDownLatch;
            this.name = name;
        }

        @Override
        public void run() {
            System.out.println(name + "开始工作...");
            // 模拟工作
            try {
                sleep((int) (Math.random() * 10000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + "工作完成。");
            countDownLatch.countDown();
        }
    }
}

首先，我们创建一个CountDownLatch实例，并将需要等待的工人数量赋值给它。然后，启动多个工人线程，每个工人需要在完成工作之后调用countDown()方法。在主线程中，我们调用await()方法等待所有工人完成工作。当所有工人都完成工作之后，在主线程中输出“所有工人工作完成，桥修好了”。