让Thread#stop方法无法终止你的线程

众所周知，Thread 类有一个 stop 方法，可以用来终止线程。当然，这个方法连同 suspend，resume 方法一起都已经被弃用了。原因是 stop 方法终止线程过于暴力，不管被 stop 的线程在干什么，一旦被 stop 它就得立刻停止执行，然后释放锁，这是非常不安全的。

那么，有没有办法，让被 stop 的线程继续执行，并且不释放锁呢？

我写了一段代码，各位可以拿去试试：

package per.lvjc.concurrent.stop;public class CanNotStopThread extends Thread {private static final Object monitor = new Object();private boolean success = false;int sum = 0;@Overridepublic void run() {synchronized (monitor) {while (!success) {try {rollback();work();System.out.println("sum = " + sum);success = true;} catch (ThreadDeath threadDeath) {//do nothing}}}}private void rollback() {System.out.println("rollback");this.sum = 0;}/* 累加 1~100 */private void work() {int i = 1;while (i < 101) {try {sleep(100);} catch (InterruptedException e) {System.out.println("What the fuck?");}System.out.println("i = " + i);sum += i++;}}public static void main(String[] args) throws InterruptedException {CanNotStopThread canNotStopThread = new CanNotStopThread();Thread thread = new Thread(() -> {synchronized (monitor) {System.out.println("acquired lock");}});canNotStopThread.start();sleep(1000);thread.start();for (int i = 0; i < 100; i++) {canNotStopThread.stop();sleep(100);}}
}

主要逻辑：

先开一个线程canNotStopThread，它的工作很简单，加锁，然后累加 1~100；
再开一个线程thread，它一直在等canNotStopThread释放锁；
最后，在主线程，循环调用stop方法 100 次，试图终止 canNotStopThread执行，让thread获得锁。

这段代码不管跑多少次，都会看到如下结果：

...
rollback
rollback
rollback
rollback
i = 1
i = 2
...
i = 98
i = 99
i = 100
sum = 5050
acquired lockProcess finished with exit code 0

反应了几点：

主线程 stop 了 100 次，但是没有起作用；
canNotStopThread线程还是正确地累加了 1~100；
canNotStopThread线程累加完毕之前，thread线程休想得到锁，stop 也没用。

stop 方法是否能让线程终止，并且释放锁？

当然能，不用怀疑。

我的这段代码，如果把 while 循环去掉，结果就会变成这样：

rollback
i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9
acquired lockProcess finished with exit code 0

没有执行完，线程被终止，然后锁丢了。

让 stop 方法不能终止线程的关键是什么？

是那个 while 循环吗？不完全是。

关键点有三个：

catch ThreadDeath（这是个 Error），并且别抛出去，直接吃掉；
catch 块一行代码都不要有，如果有 finally 块，也是一行代码都不要有，只要有代码就必须 catch ThreadDeath吃掉；
来一个循环，业务流程不执行完，不要让它停下来。

为什么要吃掉 ThreadDeath？

如果你的线程被 stop 了，不管你的线程执行到了什么地方，都会立刻抛出一个 ThreadDeath。线程的 run 方法抛了 Error，线程自然就结束了，锁自然也释放了。

所以 ThreadDeath 必须要吃掉，不能让它抛出去，抛出去线程就结束了。

为什么 catch 块和 finally 块不能有代码？

试试把 run 方法改成这样：

    @Overridepublic void run() {synchronized (monitor) {while (!success) {try {rollback();work();System.out.println("sum = " + sum);success = true;} catch (ThreadDeath threadDeath) {System.out.println("catch");try {sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}}}

或者这样：

    @Overridepublic void run() {synchronized (monitor) {while (!success) {try {rollback();work();System.out.println("sum = " + sum);success = true;} catch (ThreadDeath threadDeath) {System.out.println("catch");} finally {System.out.println("finally");try {sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}}}

这样线程就会被 stop 掉。

如果一定要在 catch 或者 finally 块里面加一些代码，比如打个日志什么的，就必须再套一层 catch：

    @Overridepublic void run() {synchronized (monitor) {while (!success) {try {rollback();work();System.out.println("sum = " + sum);success = true;} catch (ThreadDeath threadDeath) {//do nothingtry {System.out.println("catch");} catch (ThreadDeath e) {}} finally {try {System.out.println("finally");try {sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}} catch (ThreadDeath threadDeath) {}}}}}

因为你无法知道，当你的线程被 stop 的时候，它跑到哪了。如果正跑着 try 块的代码，那就没问题；如果在跑 catch 或者 finally 块代码的时候被 stop，就完蛋了。

所以，每一行代码都必须被 try 包起来，catch ThreadDeath吃掉。因为每一行代码，准确地说，每一条指令都有抛 Error 的风险。

以上，知道了 stop 方法是如何终止线程的，就有办法让它终止不掉你的线程。

当然，这个只能说是一点有意思的奇技淫巧，没什么用啊，不建议这么搞。