CountDownLatch的简单使用

CountDownLatch 是一个同步工具类，它允许一个或多个线程一直等待（CountDownLatch.await()），直到其他线程执行完后再执行。使用一个计数器进行实现，计数器初始值为线程的数量。

当每一个线程完成自己任务后，计数器的值就会减一（CountDownLatch.countDown()）。当计数器的值为0时，表示所有的线程都已经完成一些任务，然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。

public class TestThread {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool(); //线程池对象
        CountDownLatch countDownLatch=new CountDownLatch(10); //初始值为10
        for (int i = 0; i <10 ; i++) {
            executorService.execute(new countRunnable(countDownLatch));
        }
    }
}
class countRunnable implements Runnable{

    private CountDownLatch countDownLatch;

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

    @Override
    public void run() {
        synchronized (countDownLatch){
            System.out.println("Thread Counts:"+countDownLatch.getCount()); //当前数值
            countDownLatch.countDown(); //数值-1
        }
        try {
            System.out.println("concurrency counts:"+(10-countDownLatch.getCount()));
            countDownLatch.await(); //阻塞当前线程
            System.out.println("线程执行完毕："+countDownLatch.getCount());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

CountDownLatch是线程安全的，底层是基于CAS机制（乐观锁），保证对单个变量的读-改-写是原子操作。

这里去掉synchronized (countDownLatch) 会出现重复重复打印的数字是因为countDownLatch.countDown()和countDownLatch.getCount()两个原子操作组合在一起就不是原子操作了。

 

public class EmployeeThread extends Thread{

    private CountDownLatch countDownLatch;
    private String name; //员工名字
    private Long time; //耗费时间

    public EmployeeThread(CountDownLatch countDownLatch, String name, Long time) {
        this.countDownLatch = countDownLatch;
        this.name = name;
        this.time = time;
    }

    @Override
    public void run() {
        try {
            System.out.println(name+"开始准备");
            Thread.sleep(time);
            System.out.println(name+"准备完成");
            countDownLatch.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class TestEmployeeThread {
    public static void main(String[] args) {
        CountDownLatch countDownLatch=new CountDownLatch(2);
        EmployeeThread A=new EmployeeThread(countDownLatch,"A",1500L);
        EmployeeThread B=new EmployeeThread(countDownLatch,"B",1500L);
        EmployeeThread C=new EmployeeThread(countDownLatch,"C",1500L);

        B.start();
        C.start();
        try {
            countDownLatch.await(); //阻塞主线程

            //当B和C都执行完毕，countDownLatch减到0，主线程再开始执行

            System.out.println("B、C准备完成");  
            A.start();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}