Java并发-CountDownLatch

概述

一种同步帮助，它允许一个或多个线程等待，直到在其他线程中执行的一组操作完成为止。

示例

// 旅游巴士要等到每一个都准备好了才出发.

public class CountDownLatchDemo {
    //代表游客准备任务
    static class Traveler implements Runnable {
        private CountDownLatch readySignal;

        public Traveler(CountDownLatch readySignal) {
            this.readySignal = readySignal;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(new Random().nextInt(2000));
                // 减少一个计数
                readySignal.countDown();
                System.out.println("Traveler: I'm ready. rest travelers to ready:" + readySignal.getCount() + ".");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 代表巴士司机发车任务
    static class BusDriver implements Runnable {
        private CountDownLatch readySignal;

        public BusDriver(CountDownLatch readySignal) {
            this.readySignal = readySignal;
        }

        @Override
        public void run() {
            try {
                readySignal.await();
                // 让语句输出在最后面
                Thread.sleep(1000);
                System.out.println("Driver: All the travelers are ready, starting the travel bus.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        // 旅客总人数
        final int travelerCount = 30;
        // 旅客准备与司机开车同步工具
        final CountDownLatch readySignal = new CountDownLatch(travelerCount);
        // 执行器
        ExecutorService executor = Executors.newFixedThreadPool(10);
        // 执行巴士司机开车任务
        executor.submit(new BusDriver(readySignal));
        // 执行游客准备任务
        for (int i = 0; i < travelerCount; i++) {
            executor.submit(new Traveler(readySignal));
        }
        executor.shutdown();
        executor.awaitTermination(60, TimeUnit.SECONDS);
    }
}

// 将汽车组装任务分配给多个人, 要等到每一个组都组装好了,才能开始进行汽车检测.

public class CountDownLatchDemo2 {
    //代表一个汽车组装任务
    static class AssembleTask implements Runnable {
        // 当前装配任务的Id
        private int taskId;
        // 装配完成时候的信号发送工具
        private CountDownLatch completionSignal;

        public AssembleTask(int taskId, CountDownLatch completionSignal) {
            this.taskId = taskId;
            this.completionSignal = completionSignal;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(new Random().nextInt(2000));
                // 减少一个计数, 这个任务已经完成
                completionSignal.countDown();
                System.out.println("AssembleTask:" + taskId + " completion." +
                        "There are more " + completionSignal.getCount() + " AssembleTask.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //代表汽车整车检测任务
    static class QualityInspectionTask  implements Runnable {
        // 装配完成时候的信号发送工具
        private CountDownLatch completionSignal;

        public QualityInspectionTask(CountDownLatch completionSignal) {
            this.completionSignal = completionSignal;
        }

        @Override
        public void run() {
            try {
                // 等待所有的汽车组装任务完成
                completionSignal.await();
                // 防止打印在前面
                Thread.sleep(1000);
                // 开始检测任务
                System.out.println("QualityInspectionTask: assemble completed. Start to inspect");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        // 组装任务总数
        final int taskCount = 30;
        // 任务完成的同步工具
        final CountDownLatch completionSignal = new CountDownLatch(taskCount);
        // 执行器, 最多允许10个任务同时执行
        ExecutorService executor = Executors.newFixedThreadPool(10);
        // 开始执行检测整车任务
        executor.submit(new QualityInspectionTask(completionSignal));
        // 执行组装任务
        for (int i = 0; i < taskCount; i++) {
            executor.submit(new AssembleTask(i, completionSignal));
        }
        executor.shutdown();
        executor.awaitTermination(60, TimeUnit.SECONDS);
    }
}

原理

参考

CountDownLatch JDK1.7