CountDownLatch---多线程等待

import java.util.concurrent.CountDownLatch;

/**
 * @author sulishi
 * @version 1.0
 * @date 2021/1/31
 */
public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatchTest countDownLatchTest = new CountDownLatchTest();
        System.out.println(countDownLatchTest.timeTasks(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("doing something");
            }
        }));
    }


    public long timeTasks(int nThreads, final Runnable task)
            throws InterruptedException {
        final CountDownLatch startGate = new CountDownLatch(1);
        final CountDownLatch endGate = new CountDownLatch(nThreads);

        for (int i = 0; i < nThreads; i++) {
            Thread t = new Thread() {
                @Override
                public void run() {
                    try {
                        //new Thread的时候计数器为1,所有线程都不会执行下面的任务
                        startGate.await();
                        try {
                            task.run();
                        } finally {
                            //每个线程执行完成调用-1
                            endGate.countDown();
                        }
                    } catch (InterruptedException ignored) {
                    }
                }
            };
            t.start();
        }

        long start = System.nanoTime();
        //for循环创建所有线程后，再执行startGate.countDown()，计数器减为0，所有线程同时开始抢占资源，执行任务
        startGate.countDown();
        //所有线程未全部执行完，计数器就未减到0，等待
        endGate.await();
        long end = System.nanoTime();
        return end - start;
    }
}

CountDownLatch是闭锁的一种灵活实现，闭锁常用于以下场景：

1.确保某个任务在其所需要的全部资源都初始化后才继续执行

2.确保某个服务在其依赖的所有服务都已经启动之后才启动

3.等待某个操作的所有参与者都就绪再继续执行