图解java多线程设计模式（二）
一、join & interrupt
这俩方法属于线程对象里的方法，属于线程本身的操作。
1.1：join方法
用于等待一个线程的终止，等待期间将会阻塞，直到被等待的线程终止结束。
所以join可以用来做多任务异步处理，比如还是拿利用CompletableFuture优化程序的执行效率这篇里的第一个例子做优化，这篇文章里使用线程池的future模式进行多任务异步处理，现在使用join改写下：
再来简单贴下这几个方法
private String getTop() { // 这里假设getTop需要执行200ms
try {
Thread.sleep(200L);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "顶部banner位";
}
private String getLeft() { // 这里假设getLeft需要执行50ms
try {
Thread.sleep(50L);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "左边栏";
}
private String getRight() { // 这里假设getRight需要执行80ms
try {
Thread.sleep(80L);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "右边栏";
}
private String getUser() { // 这里假设getUser需要执行100ms
try {
Thread.sleep(100L);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "用户信息";
}
然后现在使用简单的线程做异步处理：
// 简单异步获取
public WebModule getWebModuleMsgSimpleAsync() throws ExecutionException, InterruptedException {
WebModule webModule = new WebModule();
Thread topTask = new Thread(() -> webModule.setTop(this.getTop()));
Thread leftTask = new Thread(() -> webModule.setLeft(this.getLeft()));
Thread rightTask = new Thread(() -> webModule.setRight(this.getRight()));
Thread userTask = new Thread(() -> webModule.setUser(this.getUser()));
//触发各个异步任务
topTask.start();
leftTask.start();
rightTask.start();
userTask.start();
//等待所有的任务均执行完毕
topTask.join();
leftTask.join();
rightTask.join();
userTask.join();
return webModule;
}
测试代码：
@Test
public void testSimpleASync() throws Exception {
// 同步方法测试，预估耗时200ms
long start = System.currentTimeMillis();
WebModule module = webHome.getWebModuleMsgSimpleAsync();
System.out.println("通过异步方法获取首页全部信息消耗时间：" + (System.currentTimeMillis() - start) + "ms");
System.out.println("结果为：" + module.toString());
}
测试结果：
通过异步方法获取首页全部信息消耗时间：272ms
结果为：top: 顶部banner位; left: 左边栏; right: 右边栏; user: 用户信息
比预估的要多72ms，经过后来的测试，发现这72ms耗时发生在线程创建的时候，以及后续线程状态转换带来的消耗，下面等待异步结束的时间约等于200ms，符合预期。
1.2：interrupt方法
用于主动终止一个线程，线程本身调用该方法后，视为已终止状态，join解除阻塞，下面来用interrupt和join来做个实验：
public class JoinTest {
private boolean isStop = false;
public static void main(String[] args) throws Exception {
JoinTest test = new JoinTest();
Thread loopT = new Thread(test::loopTask);
loopT.start();
sleep(2000L); //2s后终止线程
test.setStop(true);
long s = System.currentTimeMillis();
loopT.join();
System.out.println("线程终止后，join阻塞时间为：" + (System.currentTimeMillis() - s));
System.out.println("end~");
}
public void setStop(boolean stop) {
isStop = stop;
}
public void loopTask() {
while (!isStop) { //若状态为false，则继续执行下面的逻辑，每隔1s打印一次
sleep(1000L);
System.out.println("loop trigger ~");
}
Thread.currentThread().interrupt(); //在这里终止掉当前线程
//事实上，在终止掉线程后，还有接下来的逻辑要执行
long s = System.currentTimeMillis();
for (int i = 0; i < 1000000; i++) {
int[] a = new int[100]; //模拟耗时操作，这里不能用sleep了，因为当前线程已经被终止了
}
System.out.println("线程终止后，逻辑块运行时间：" + (System.currentTimeMillis() - s));
}
public static void sleep(long time) {
try {
Thread.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
执行结果：
loop trigger ~
loop trigger ~
线程终止后，逻辑块运行时间：129
线程终止后，join阻塞时间为：129
end~
即便线程被终止了，后面的逻辑也会触发，join依旧会选择阻塞，直到后续逻辑执行完毕，事实上，大部分任务都可以及时的终止，比如第一个例子，异步出去的任务，最终都会执行完成，线程变为终止状态，join都可以顺利结束，但是反观上例，如果没人及时的设置isStop的值，程序会一直执行下去，没有终止态，join会无止境的终止下去，这里提一下stop，线程的stop方法已被官方标记为“不建议使用”的方法，如果把上例的interrupt的调用换成stop，来看看其运行结果：
loop trigger ~
loop trigger ~
线程终止后，join阻塞时间为：0
end~
可以看到，线程终止后的后续逻辑均没有触发，等于说stop是一种很粗暴的终止线程的方式，一旦被stop，那么里面的业务逻辑将直接断掉，因此官方并不推荐使用该方法来终止线程。
而interrupt，仅仅是对目标线程发送了了一个中断信号（改变了线程的中断状态而已），当目标线程再次通过obj.wait、thread.sleep、thread.join方法进入阻塞状态时，接收到该信号，就会抛出InterruptedException异常，这时候需要业务方自行处理或者直接抛出，以结束线程阻塞状态（这里需要注意的是被obj.wait方法阻塞时，抛出该异常需要目标线程再次获得实例对象obj的锁才行）。
上述三个“需要花费时间”的方法均抛出了InterruptedException异常，针对这些特性，想要完成以下操作就非常方便了：
①取消wait方法等待notify/notifyAll的处理
②取消在sleep方法指定时间内停止的处理
③取消join方法等待其他线程终止的处理
取消之后所做的处理，取决于需求，可能会终止线程，或者通知用户已取消，或者终止当前处理进入下一个处理阶段。
二、线程状态迁移图
图1
上面的图太多太杂，我们通过对一些可以影响线程状态的操作的分类，来简化一下上面的图：
图2
