Thread.stop() 与 ThreadDeath 的理解、注意点以及误区

通常情况下终止线程的方式是使用中断，或者使用一个标志位。但这些方法只适用于我们自己编写的代码，即我们知道代码是如何实现的、是否响应中断、是否是用标志位判断终止与否。但对于外部代码，比如说来着网络的 class 文件，其中有一个死循环，我们用一个线程来执行它，如何才能终止它的执行？我的方式是 Thread.stop() 与 ThreadDeath。

Thread.stop() 可以强制线程停止执行。会停止执行当前代码并抛出 ThreadDeath 错误。使用时要注意一下几点：

1. Thread.stop() 方法有缺陷，它会解锁已锁定的所有监视器（synchronized 锁）。 如果这些锁之前保护的任何对象处于不一致的状态，则损坏的对象将对其他线程可见，从而可能导致任意行为。
2. 默认的情况下，顶级的异常处理器不会打印关于 ThreadDeath 的信息，也不会以其他方式通知应用程序。若要获取 ThreadDeath 的信息，必须手动捕获 ThreadDeath。
3. 如果我们捕获了 ThreadDeath 但又做了其他的操作，线程则无法及时终止。
4. Thread.stop() 和 Thread.interrupt() 都只是以抛出异常的方式给了应用程序一个通知，都不是强制终止线程，最起码不像 kill -9 tid 那样强制、暴力、有效。区别在于 Thread.interrupt() 只能在响应中断的方法上抛出异常，而 Thread.stop() 可以在任意地方抛出异常。

Thread.stop() 的缺陷

在下面的代码中，count、list 由 lock 保护，count 自增的同时，list 中也应该添加一个元素，也就是说 count 和 list.size() 始终都应该一样。但如果在 count++ 之后，还没来得及执行 list.add(new Object()) 时调用了 thread.stop()，这会导致线程终止并释放锁，造成数据的不一致，count、list.size() 分别为 1 和 0。

private static final Object lock = new Object();

private static int count = 0;

private static final List<Object> list = new LinkedList<>();


public static void main(String[] args) throws InterruptedException {

    Runnable runnable = () -> {
        synchronized (lock) {
            count++;

            longTime();

            list.add(new Object());
        }
    };

    Thread thread = new Thread(runnable);
    thread.start();

    Thread.sleep(10);
    thread.stop();

    synchronized (lock) {
        System.out.println(count);
        System.out.println(list.size());
    }
}

public static void longTime() {
    for (int i = 0; i < Integer.MAX_VALUE; i++) {
        for (int j = 0; j < Integer.MAX_VALUE; j++) {}
    }
}

// 执行结果
1
0

顶级的异常处理器不会打印关于 ThreadDeath 的信息

以下代码不会打印任何错误信息：

public static void main(String[] args) throws InterruptedException {

    Runnable runnable = () -> {
        for (;;) {}
    };

    Thread thread = new Thread(runnable);
    thread.start();

    Thread.sleep(10);
    thread.stop();
}

必须手动捕获 ThreadDeath，手动打印错误信息

Runnable runnable = () -> {
    try {
        for (;;) {}
    } catch (ThreadDeath e) {
        e.printStackTrace();
    }
};

错误信息：

java.lang.ThreadDeath
	at java.base/java.lang.Thread.stop(Thread.java:1717)
	at com.example.test.main(T2.java:29)

ThreadDeath 只是一个通知，捕获 ThreadDeath 可导致线程不会终止

public static void main(String[] args) throws InterruptedException {

    Runnable runnable = () -> {
        try {
            for (;;) {}
        } catch (ThreadDeath e) {
            e.printStackTrace();
            int i = 0;
            for (;;) {
                System.out.println(i++);
            }
        }
    };

    Thread thread = new Thread(runnable);
    thread.start();
    thread.stop();
}

上述代码中的线程不会终止，应该会一直打印，但我在测试时打印到 348067 左右就停了，但 jvm 没有退出，不知道为什么？？？

java.lang.ThreadDeath
	at java.lang.Thread.stop(Thread.java:858)
	at T3.main(T3.java:28)
0
1
2
3
4
5
6
7
8

执行外部代码，超时自动终止线程的例子

假设外部代码实现了 Runnable 接口

public static void main(String[] args) throws InterruptedException {

    Runnable runnable = () -> {
        for (;;) {}
    };
    invoke(runnable, 10, TimeUnit.SECONDS);
}

public static void invoke(Runnable runnable, long timeout, TimeUnit timeUnit) {
    Thread thread = new Thread(runnable, "thread-runnable-xx");
    thread.start();
    try {
        thread.join(timeUnit.toMillis(timeout));
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    thread.stop();
}

这种方法有一个缺陷：如果外部代码捕获了 ThreadDeath，可能线程就无法终止了。例如：

public static void main(String[] args) throws InterruptedException {

    Runnable runnable = () -> {
        try {
            for (;;) {}
        } catch (ThreadDeath e) {
            e.printStackTrace();
            int i = 0;
            for (;;) {
                System.out.println(i++);
            }
        }
    };
    invoke(runnable, 10, TimeUnit.SECONDS);
}

参考

• Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?