主要讲解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
里面的注释其实已经很清晰了，简单总结一下流程：
- 初始化startGate和endGate的计数器，分别为1和5；
- 开启5个线程，去执行RunnableTask任务；
- 5个线程启动后，会全部阻塞在startGate.await()；
- 当调用startGate.countDown()，startGate计数器为0，线程阀门放开，开始一起去执行每个线程任务task.run()；
- 每个线程执行完毕后，会调用endGate.countDown()，每调用一次，endGate的计数器减去1，线程执行过程中，主线程通过endGate.await()阻塞；
- 当所有线程执行完毕，endGate计数器为0，主线程endGate.await()阻塞放开，执行后面收尾流程，流程结束。
这个和Go的sync.WaitGroup，简直一毛一样啊！看来语言的设计，很多都差不多。
FutureTask
FutureTask也可以用作闭锁，它是通过Callabale来实现，相当于一种可以生成结果的Runnable，并且可以处于以下3种状态：等待状态，正在运行和运行完成。Future.get的行为取决于任务的状态，如果任务已经完成，那么get会立即返回结果，否则get将阻塞到任务进入完成状态，然后返回结果或者抛出异常。
@Data @Service public class Cat { private String catName; } public class Preloader { private final FutureTask<Cat> future = new FutureTask<Cat>(new Callable<Cat>() { @Override public Cat call() throws InterruptedException { Cat cat = new Cat(); cat.setCatName("罗小黑"); for (int i = 1; i <= 5; i ++) { // 睡眠1秒，方便大家看执行效果 Thread.sleep(1000L); System.out.println("Sleep " + i + " 秒"); } return cat; } }); private final Thread thread = new Thread(future); public void start() { System.out.println("启动Start"); thread.start(); } public Cat get() throws ExecutionException, InterruptedException { Cat cat = null; try { System.out.println("开始获取数据！"); // 阻塞，等待线程执行完毕 cat = future.get(); System.out.println("获取数据成功！"); } catch (ExecutionException e) { // 异常处理，省略... } return cat; } public static void main(String args[]) throws ExecutionException, InterruptedException { Preloader preloader = new Preloader(); preloader.start(); Cat cat = preloader.get(); System.out.println(cat.toString()); } } // 输出： // 启动Start // 开始获取数据！ // Sleep 1 秒 // Sleep 2 秒 // Sleep 3 秒 // Sleep 4 秒 // Sleep 5 秒 // 获取数据成功！ // Cat(catName=罗小黑)
我们可以看到，获取Cat数据时，主线程一直阻塞住，直到Cat成功构造好数据后，才正常返回，简单总结一下流程：
- 初始化线程对象Thread和FutureTask静态对象，其中FutureTask的Callable是构造Cat数据；
- 启动线程thread.start()，开始执行future中Callable.call()方法，开始构造Cat数据；
- 在Cat数据构造成功前，future.get()会一直阻塞，直到future中Callable.call()成功返回，阻塞结束。
信号量
用途：用来控制同时访问某个特定资源的操作数量，或者同时执行某个指定操作的数量。计数信号量可以用来实现某种资源池，或者对容器施加边界。
public class SemaphoreTest<T> { public final Set<T> set; private final Semaphore sema; public SemaphoreTest(int bound){ this.set = Collections.synchronizedSet(new HashSet<T>()); this.sema = new Semaphore(bound); } public boolean add(T o) throws InterruptedException{ sema.acquire(); boolean wasAdded = false; try{ wasAdded = set.add(o); return wasAdded; }finally{ if(!wasAdded){ sema.release(); } } } public boolean remove(T o){ boolean wasRemoved = set.remove(o); if(wasRemoved){ sema.release(); } return wasRemoved; } public static void main(String[] args) throws InterruptedException{ int permits = 5; SemaphoreTest<Integer> test = new SemaphoreTest<Integer>(permits); for(int i = 0; i < 10; i++){ test.add(i); System.out.println("set:" + test.set); } } } // 输出： // set:[0] // set:[0, 1] // set:[0, 1, 2] // set:[0, 1, 2, 3] // set:[0, 1, 2, 3, 4]
这个示例就很简单，描述一下流程：
- 先初始化信号量sema的许可个数为5；
- 通过add()添加数据，每添加一个数据，就消耗sema的一个许可；
- 当5个许可全部消耗完毕后，如果需要再添加数据，因为sema的许可为0，阻塞请求。备注：如果这个时候调用了sema.release()，会释放一个许可，那么add()会继续添加一个元素，之后的请求继续阻塞，直到有新的许可释放。
栅栏
上面介绍的都是闭锁的几种实现方式，栅栏类似于闭锁，它能阻塞一组线程直到某个时间发生。栅栏和闭锁的关键区别在于，所有线程必须同时到达栅栏位置，才能继续执行。书中有一句哈总结的很好：
闭锁用于等待事件，而栅栏用于等待其它线程。
用途：用于阻塞一组线程直到某个事件发生。所有线程必须同时到达栅栏位置才能继续执行下一步操作，且能够被重置以达到重复利用。而闭锁式一次性对象，一旦进入终止状态，就不能被重置。
public class CyclicBarrierWorker implements Runnable { private int id; private CyclicBarrier barrier; public CyclicBarrierWorker(int id, final CyclicBarrier barrier) { this.id = id; this.barrier = barrier; } @Override public void run() { try { if (id == 5) { // 让第5个线程sleep 10秒 Thread.sleep(10000); } System.out.println(id + " people wait"); barrier.await(); // 大家等待最后一个线程到达 } catch (InterruptedException | BrokenBarrierException e) { e.printStackTrace(); } } } class TestCyclicBarrier { public static void main(String[] args) { int num = 10; // 新建一个栅栏 CyclicBarrier barrier = new CyclicBarrier(num, new Runnable() { @Override public void run() { // num个线程全部执行完毕，且都调用barrier.await()，才会去执行该方法 // 可以理解为计数器初始值为num，每调用一次barrier.await()，计数器-1，直到计数器等于0 System.out.println("go on together!"); } }); for (int i = 1; i <= num; i++) { new Thread(new CyclicBarrierWorker(i, barrier)).start(); } } } // 输出： // 1 people wait // 3 people wait // 4 people wait // 2 people wait // 6 people wait // 7 people wait // 8 people wait // 9 people wait // 10 people wait // 5 people wait // go on together!
我故意让第5个线程sleep了10秒，所以大家都等第五个线程，全部执行完毕后，再一起去执行栅栏中的任务，简单总结一下流程：
- 新建一个栅栏，第一个参数num是线程个数，第二个参数是栅栏需要执行的任务；
- 启动10个线程，每个线程传入栅栏变量，这10个线程开始执行，然后都阻塞在barrier.await()，大家都在等待最后一个线程的到达；
- 当最后一个线程到达barrier.await()后，阻塞放开，开始执行栅栏中的方法。
创建线程的三种方式
如果大家对线程创建非常清楚，可以直接跳过“创建线程的三种方式”这部分内容，该部分内容主要给Java小白扫盲。
继承Thread类
继承Thread类并复写run()方法，是一种很简单的方式，代码如下：
public class MyThread extends Thread { public MyThread(String name) { super(name); } @Override public void run() { String name = Thread.currentThread().getName(); System.out.println(name + "已经运行"); } public static void main(String[] args) { new MyThread("线程一").start(); } } // 输出： // 线程一已经运行
实现Runnable接口
这个是我们经常使用的方式之一，代码如下：
public class MyTask implements Runnable { @Override public void run() { String name = Thread.currentThread().getName(); System.out.println(name + "已经运行"); } public static void main(String[] args) { new Thread(new MyTask(),"线程二").start(); } } // 输出： // 线程二已经运行
Callable与Future创建线程
我们看到不管是Thread还是Runable接口，其run()都是无返回值的，并且无法抛出异常的，如果我们有需要返回值或者抛出异常怎么办？这个时候就需要用到Callable与Feature了。先来看类的继承关系:
可以看到Callable是一个接口，里面有个V call()方法，这个V就是我们返回值类型，同时还有Future相关的类，注意观察FutureTask类的构造函数，我们发现其中一个构造函数的参数是Callable类型，这里就把两个内联系起来了。Callable与Future的用法如下：
public class CallableTest { private void callTest() { //这里指定返回String类型 Callable<String> callable = new Callable<String>() { @Override public String call() throws Exception { System.out.println("Callable 已经运行啦"); return "this is Callable is running"; } }; FutureTask<String> futureTask = new FutureTask<String>(callable); futureTask.run(); try { if (futureTask.isDone()){ //任务完成 System.out.println(futureTask.get()); } } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } public static void main(String[] args) { CallableTest test = new CallableTest(); test.callTest(); } }
用法：一般都先new一个Callable对象，并重写里面的call()方法，这个方法需要借助FutureTask来执行，当通过Callable对象生成FutureTask对象后，直接执行futureTask.run()，即可调用Callable对象的call()方法。
我们还可以通过Future提供的接口，对任务进行如下操作：
public interface Future<V> { // 取消任务，如果任务正在运行的，mayInterruptIfRunning为true时，表明这个任务会被打断的，并返回true； // 为false时，会等待这个任务执行完，返回true；若任务还没执行，取消任务后返回true，如任务执行完，返回false boolean cancel(boolean mayInterruptIfRunning); // 判断任务是否被取消了,正常执行完不算被取消 boolean isCancelled(); // 判断任务是否已经执行完成，任务取消或发生异常也算是完成，返回true boolean isDone(); // 获取任务返回结果，如果任务没有执行完成则等待完成将结果返回，如果获取的过程中发生异常就抛出异常， // 比如中断就会抛出InterruptedException异常等异常 V get() throws InterruptedException, ExecutionException; // 在规定的时间如果没有返回结果就会抛出TimeoutException异常 V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; }
原理：其实FutureTask内部实现比较简单，Callable就是他的任务，而FutureTask内部维护了一个任务状态，所有的状态都是围绕这个任务来进行的，随着任务的进行，状态也在不断的更新。任务发起者调用get()方法时，如果任务没有执行完成，会将当前线程放入阻塞队列等待，当任务执行完后，会唤醒阻塞队列中的线程。
总结
这篇文章讲解了Java常用的同步工具类，这是很多是《Java并发编程实战》书里面的内容，但是当我看书时，感觉书中讲的知识并不容易懂，对于不懂的地方，我就到网上找一些相关示例，或者对一些基础知识做一些扫盲。所以大家看书时，不懂的地方可以跳过去，然后再单独对于不懂的知识点，到网上查阅资料，因为网上有很多博客，写的真的是非常好，比很多书籍作者表述的要好很多，这个也算是我看书的一点点心得。
