简介

工作中咱们常常会用到线程，个别状况下咱们让线程执行就完事了，那么你们有没有想过如何去终止一个正在运行的线程呢？

明天带大家一起来看看。

Thread.stop被禁用之谜

问道怎么终止一个线程，可能大多数人都晓得能够调用Thread.stop办法。

然而这个办法从jdk1.2之后就不举荐应用了，为什么不举荐应用呢？

咱们先来看下这个办法的定义：

  @Deprecated(since="1.2")    public final void stop() {        @SuppressWarnings("removal")        SecurityManager security = System.getSecurityManager();        if (security != null) {            checkAccess();            if (this != Thread.currentThread()) {                security.checkPermission(SecurityConstants.STOP_THREAD_PERMISSION);            }        }        // A zero status value corresponds to "NEW", it can't change to        // not-NEW because we hold the lock.        if (threadStatus != 0) {            resume(); // Wake up thread if it was suspended; no-op otherwise        }        // The VM can handle all thread states        stop0(new ThreadDeath());    }

从代码咱们能够看出，stop这个办法首先检测有没有线程拜访的权限。如果有权限的话，来判断以后的线程是否是刚刚创立的线程，如果不是刚刚创立的，那么就调用resume办法来解除线程的暂停状态。

最初调用stop0办法来完结线程。

其中resume和stop0是两个native的办法，具体的实现这里就不讲了。

看起来stop办法很正当，没有什么问题。那么为什么说这个办法是不平安的呢？

接下来咱们来看一个例子。

咱们创立一个NumberCounter的类，这个类有一个increaseNumber的平安办法，用来对number加一：

public class NumberCounter {    //要保留的数字    private volatile int number=0;    //数字计数器的逻辑是否残缺    private volatile boolean flag = false;    public synchronized int increaseNumber() throws InterruptedException {        if(flag){            //逻辑不残缺            throw new RuntimeException("逻辑不残缺，数字计数器未执行结束");        }        //开始执行逻辑        flag = true;        //do something        Thread.sleep(5000);        number++;        //执行结束        flag=false;        return number;    }}

事实上，在理论工作中这样的办法可能须要执行比拟久的工夫，所以这里咱们通过调用Thread.sleep来模仿这个耗时操作。

这里咱们还有一个flag参数，来标记这个increaseNumber办法是否胜利执行结束。

好了，接下来咱们在一个线程中调用这个类的办法，看看会产生什么：

    public static void main(String[] args) throws InterruptedException {        NumberCounter numberCounter= new NumberCounter();        Thread thread = new Thread(()->{            while (true){                try {                    numberCounter.increaseNumber();                } catch (InterruptedException e) {                   e.printStackTrace();                }            }        });        thread.start();        Thread.sleep(3000);        thread.stop();        numberCounter.increaseNumber();    }

这里，咱们创立了一个线程，等这个线程运行3秒钟之后，间接调用thread.stop办法，后果咱们发现呈现了上面的异样：

Exception in thread "main" java.lang.RuntimeException: 逻辑不残缺，数字计数器未执行结束    at com.flydean.NumberCounter.increaseNumber(NumberCounter.java:12)    at com.flydean.Main.main(Main.java:18)

这是因为thread.stop办法间接终止了线程的运行，导致mberCounter.increaseNumber未执行结束。

然而这个未执行结束的状态是暗藏的，如果应用thread.stop办法来终止线程，很有可能导致未知的后果。

所以，咱们说thread.stop是不平安的。

怎么能力平安？

那么，如果不调用thread.stop办法，怎么能力平安的终止线程呢？

所谓平安，那就是须要让线程外面的逻辑执行结束，而不是执行一半。

为了实现这个成果，Thread为咱们提供了三个比拟相似的办法，他们别离是interrupt、interrupted和isInterrupted。

interrupt是给线程设置中断标记；interrupted是检测中断并革除中断状态；isInterrupted只检测中断。还有重要的一点就是interrupted是类办法，作用于以后线程，interrupt和isInterrupted作用于此线程，即代码中调用此办法的实例所代表的线程。

interrupt就是中断的办法，它的工作流程如下：

  1. 如果以后线程实例在调用Object类的wait（），wait（long）或wait（long，int）办法或join（），join（long），join（long，int）办法，或者在该实例中调用了Thread.sleep（long）或Thread.sleep（long，int）办法，并且正在阻塞状态中时，则其中断状态将被革除，并将收到InterruptedException。
  2. 如果此线程在InterruptibleChannel上的I/O操作中处于被阻塞状态，则该channel将被敞开，该线程的中断状态将被设置为true，并且该线程将收到java.nio.channels.ClosedByInterruptException异样。
  3. 如果此线程在java.nio.channels.Selector中处于被被阻塞状态，则将设置该线程的中断状态为true，并且它将立刻从select操作中返回。
  4. 如果下面的状况都不成立，则设置中断状态为true。

在下面的例子中，NumberCounter的increaseNumber办法中，咱们调用了Thread.sleep办法，所以如果在这个时候，调用了thread的interrupt办法，线程就会抛出一个InterruptedException异样。

咱们把下面调用的例子改成上面这样：

    public static void main(String[] args) throws InterruptedException {        NumberCounter numberCounter = new NumberCounter();        Thread thread = new Thread(() -> {            while (true) {                try {                    numberCounter.increaseNumber();                } catch (InterruptedException e) {                    System.out.println("捕捉InterruptedException");                    throw new RuntimeException(e);                }            }        });        thread.start();        Thread.sleep(500);        thread.interrupt();        numberCounter.increaseNumber();    }

运行之后再试一次：

Exception in thread "main" Exception in thread "Thread-0" java.lang.RuntimeException: 逻辑不残缺，数字计数器未执行结束    at com.flydean.NumberCounter.increaseNumber(NumberCounter.java:12)    at com.flydean.Main2.main(Main2.java:21)java.lang.RuntimeException: java.lang.thread.interrupt: sleep interrupted    at com.flydean.Main2.lambda$main$0(Main2.java:13)    at java.base/java.lang.Thread.run(Thread.java:833)Caused by: java.lang.InterruptedException: sleep interrupted    at java.base/java.lang.Thread.sleep(Native Method)    at com.flydean.NumberCounter.increaseNumber(NumberCounter.java:17)    at com.flydean.Main2.lambda$main$0(Main2.java:10)    ... 1 more捕捉InterruptedException

能够看到，咱们捕捉到了这个InterruptedException,并且得悉具体的起因是sleep interrupted。

捕捉异样之后的解决

从下面的剖析能够得悉，thread.stop跟thread.interrupt的体现机制是不一样的。thread.stop属于轻轻终止,咱们程序不晓得，所以会导致数据不统一，从而产生一些未知的异样。

而thread.interrupt会显示的抛出InterruptedException,当咱们捕捉到这个异样的时候，咱们就晓得线程外面的逻辑在执行的过程中受到了内部作用的烦扰，那么咱们就能够执行一些数据恢复或者数据校验的动作。

在下面的代码中，咱们是捕捉到了这个异样，打印出异样日志，而后向上抛出一个RuntimeException。

失常状况下咱们是须要在捕捉异样之后，进行一些解决。

那么本人解决完这个异样之后，是不是就完满了呢？

答案是否定的。

因为如果咱们本人解决了这个InterruptedException, 那么程序中其余局部如果有依赖这个InterruptedException的话，就可能会呈现数据不统一的状况。

所以咱们在本人解决完InterruptedException之后，还须要再次抛出这个异样。

怎么抛出InterruptedException异样呢？

有两种形式，第一种就是在调用Thread.interrupted()革除了中断标记之后立刻抛出：

   if (Thread.interrupted())  // Clears interrupted status!       throw new InterruptedException();

还有一种形式就是，在捕捉异样之后，调用Thread.currentThread().interrupt()再次中断线程。

public void run () {  try {    while (true) {      // do stuff    }  }catch (InterruptedException e) {    LOGGER.log(Level.WARN, "Interrupted!", e);    // Restore interrupted state...    Thread.currentThread().interrupt();  }}

这两种形式都能达到料想的成果。

总结

线程不能调用stop来终止次要是因为不会抛出异样，从而导致一些平安和数据不统一的问题。所以，最好的形式就是调用interrupt办法来解决。

本文的例子https://github.com/ddean2009/learn-java-base-9-to-20/tree/master/how-to-stop-thread

更多文章请看 www.flydean.com