【CountDownLatch】

CountDownLatch是一个计数器，允许一个或多个线程等待某些操作完成后在同时执行。当计数器等于0时，等待的线程才可以同时执行。
例如：CountDownLatch status= new CountDownLatch(5);意味着定义了5个计数器的CountDownLatch；
主要方法：

1. await 方法：当线程调用该方法后，线程会立即处于阻塞状态；直至 CountDownLatch 的计数器数量变为 0 后，才会继续执行。
2. await(long timeout, TimeUnit unit)：与 await 类似，但是它存在一个超时时间，当到达超时时间后，无论 CountDownLatch 是否变为 0，该方法都会跳出阻塞，继续向下执行。
3. countDown 方法：对CountDownLatch中计数器的数量减 1。

import java.util.concurrent.CountDownLatch;

/**
 * 功能描述:
 *
 * @author: ys
 */

import lombok.SneakyThrows;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * 功能描述:
 *
 * @author: ys
 */
public class CountDownLatchTest {
    public long task(int nThread, Runnable task) throws InterruptedException {
        final CountDownLatch start = new CountDownLatch(1);
        final CountDownLatch end = new CountDownLatch(nThread);
        for (int i = 0; i < nThread; i++) {
            Thread t = new Thread() {
                @Override
                public void run() {
                    try {
                        //阻塞,先进行记时
                        start.await();
                        try {
                            //执行子线程任务
                            task.run();
                        } finally {
                            //子线程任务计数减一
                            end.countDown();
                        }
                    } catch (InterruptedException e) {
                    }
                }
            };
            t.start();
        }
        //记时开始
        long startTime = System.currentTimeMillis();
        //计数减一
        start.countDown();
        //等待所有的子线程执行完毕
        end.await();
        System.out.println("子线程全部结束了");
        long endTime = System.currentTimeMillis();
        long time = endTime - startTime;
        return time;

    }
    public static void main(String[] args) {
        CountDownLatchTest countDownLatchTest = new CountDownLatchTest();
        try {

            long time = countDownLatchTest.task(4, new Runnable() {
                @SneakyThrows
                @Override
                public void run() {
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println("子线程执行");
                }
            });
            System.out.println("耗时：" + time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

执行结果：
子线程执行
子线程执行
子线程执行
子线程执行
子线程全部结束了
耗时：2016