关于java:还不知道如何在java中终止一个线程快来一文给你揭秘

4次阅读

共计 5029 个字符，预计需要花费 13 分钟才能阅读完成。

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

明天带大家一起来看看。

问道怎么终止一个线程，可能大多数人都晓得能够调用 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 就是中断的办法，它的工作流程如下：

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