主要讲解Java常用的同步工具类，包括闭锁/FutureTask/信号量/栅栏，最后还对“创建线程的三种方式”进行简单的扫盲。

前言

《Java并发编程实战》这本书看到第五章了，里面的同步工具类感觉比较常用，就简单总结一下。不过在讲“同步工具类”前，大家需要对创建线程的三种方法非常清楚，如果这个不清楚的话，直接看示例可能不太懂，文章最后面有“创建线程的三种方式”内容，已经给Java小白扫盲，谁让楼哥是暖男呢。

同步工具类

闭锁

用途：可用于命令一组线程在同一个时刻开始执行某个任务，或者等待一组相关的操作结束，尤其适合计算并发执行某个任务的耗时。

public class CountDownLatchTest {
    public void 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 {
                        // 阻塞，等待startGate.countDown()的执行
                        startGate.await();
                        try {
                            task.run();
                        } finally {
                            // 每次执行完毕后，计数器减1，表示有一个事件已经完成
                            endGate.countDown();
                        }
                    } catch(InterruptedException e) {
                        System.out.println("Throw Exception, e:" + e.toString());
                    }
                }
            };
            // 启动线程
            t.start();
        }

        long start = System.nanoTime();
        System.out.println("打开闭锁");
        startGate.countDown(); // 打开开关，进入startGate.await()后面的逻辑
        endGate.await(); // 等待所有线程endGate.countDown()全部执行完毕
        long end = System.nanoTime();
        System.out.println("闭锁退出，共耗时" + (end-start));
    }

    class RunnableTask implements Runnable {
        @Override
        public void run() {
            System.out.println("当前线程为：" + Thread.currentThread().getName());
        }
    }

    public static void main(String args[]) throws InterruptedException {
        CountDownLatchTest test = new CountDownLatchTest();
        test.timeTasks(5, test.new RunnableTask());
    }
}
// 输出：
// 打开闭锁
// 当前线程为：Thread-0
// 当前线程为：Thread-2
// 当前线程为：Thread-1
// 当前线程为：Thread-3
// 当前线程为：Thread-4
// 闭锁退出，共耗时1985771

里面的注释其实已经很清晰了，简单总结一下流程：

1. 初始化startGate和endGate的计数器，分别为1和5；
2. 开启5个线程，去执行RunnableTask任务；
3. 5个线程启动后，会全部阻塞在startGate.await()；
4. 当调用startGate.countDown()，startGate计数器为0，线程阀门放开，开始一起去执行每个线程任务task.run()；
5. 每个线程执行完毕后，会调用endGate.countDown()，每调用一次，endGate的计数器减去1，线程执行过程中，主线程通过endGate.await()阻塞；
6. 当所有线程执行完毕，endGate计数器为0，主线程endGate.await()阻塞放开，执行后面收尾流程，流程结束。

这个和Go的sync.WaitGroup，简直一毛一样啊！看来语言的设计，很多都差不多。

FutureTask

FutureTask也可以用作闭锁，它是通过Callabale来实现，相当于一种可以生成结果的Runnable，并且可以处于以下3种状态：等待状态，正在运行和运行完成。Future.get的行为取决于任...