【Java并发编程系列6】同步工具类
主要讲解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并发编程实战》书里面的内容，但是当我看书时，感觉书中讲的知识并不容易懂，对于不懂的地方，我就到网上找一些相关示例，或者对一些基础知识做一些扫盲。所以大家看书时，不懂的地方可以跳过去，然后再单独对于不懂的知识点，到网上查阅资料，因为网上有很多博客，写的真的是非常好，比很多书籍作者表述的要好很多，这个也算是我看书的一点点心得。
欢迎大家多多点赞，更多文章，请关注微信公众号“楼仔进阶之路”，点关注，不迷路~~