闭锁

闭锁是一种同步工具类，可以延迟线程的进度直到线程到达终止状态。可以用于确保某些活动直到其他活动都完成后继续执行：

• 确保某个计算在其需要的所有资源都被初始化之后继续执行
• 确保某个服务在其依赖的所有其他服务都已经启动之后才启动。
• 等待直到某个操作的所有参与者都就绪再继续执行。

闭锁就像是一扇门，在闭锁到达结束状态之前，这扇门一直关闭的，并且没有任何线程能够通过，当到达结束状态时，这扇门会打开并允许所有的线程通过。（当闭锁到达结束状态后，将不会再改变状态）

CountDownLatch 是一种灵活的闭锁实现，可以使一个或多个线程等待一组事件发生。闭锁状态包括一个计数器，该计数器被初始化成为一个正数，表示需要等待的事件数量。countDown 方法递减计数器，表示有一个事件已经发生。await 方法等待计数器到达零，这表示所有需要等待的事件都已经发生。

public class TestHarness {

    public long timeTask(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++) {
            new Thread(){
                @Override
                public void run() {
                    try {
                        startGate.await();
                        try {
                            task.run();
                        } finally {
                            endGate.countDown();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }.start();
        }

        long startTime = System.nanoTime();
        startGate.countDown();
        endGate.await();
        long endTime = System.nanoTime();
        return endTime - startTime;
    }

    public static void main(String[] args) throws InterruptedException {
        long time = new TestHarness().timeTask(10, new Runnable() {
            public void run() {
                System.out.println("Current Thread : " + Thread.currentThread().getName());
            }
        });

        System.out.println("Task execute time : " + time);
    }
}

结果