撸一撸如何优雅地中止线程？-如何优雅的终止线程

[[320148]]

本文来学习如何学习优雅地中止线程?通过 Java 线程的生老病死的学习，我相信大家对线程的运行以及线程的状态有一定了解了，那么我们现在来学习中止线程：

错误的线程中止 - stop

首先来讲解一个错误的方式来中止线程 — stop：中止线程，并且清除监控器锁的信息，但是可能导致线程安全问题，JDK 不建议使用，类似的方法还有 destory，由于 JDK 从未实现该方法，在这里就不介绍了。

接下来通过一段程序来讲解为什么 stop 会导致线程安全问题?

首先定义一个线程类 StopThread：

public class StopThread extends Thread { 
    private int i = 0; 
    private int j = 0; 
 
    @Override 
    public void run() { 
        synchronized (this) { 
            // 增加同步锁，确保线程安全 
            ++i; 
            try { 
                // 休眠10秒,模拟耗时操作 
                Thread.sleep(10000); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
            ++j; 
        } 
    } 
 
    /** 
     * 打印 i 和 j 
     */ 
    public void print() { 
        System.out.println("i=" + i + " j=" + j); 
    } 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

这个线程做的事情就是在同步代码块中对 i 和 j 这两个变量进行自增操作，但是在这个执行过程中会进行 10 秒的睡眠，如果在这个过程中，如果用 stop 方法将线程中止的话，会导致 i 和 j 数据不正确，也可以说程序设计上的线程安全问题，因为主线程影响到了创建的 StopThread 线程的数据不正确性，理想的正确输出结果应该是要么全部添加成功，要么都失败，因为我们添加锁的目的就是保证操作原子性或者说想让这两个变量在操作的时候不受其他线程干扰。

下面编写 StopThreadDemo 类，来使用 stop 方法做个错误示范：

public class StopThreadDemo { 
    public static void main(String[] args) throws InterruptedException { 
        StopThread thread = new StopThread(); 
        thread.start(); 
        // 休眠 1 秒，确保 i 变量自增成功 
        Thread.sleep(1000); 
        // 暂停线程 
        thread.stop(); // 错误的终止 
        while (thread.isAlive()) { 
            // 确保线程已经终止 
        } // 输出结果 
        thread.print(); 
    } 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

在 StopThreadDemo 类中，创建并启动了 StopThread 线程，这个线程就是下执行变量i 和 j 的自增操作，但是这个自增操作是用同步关键字包裹的同步代码块，这样做是为了让两个变量的自增操作实现原子性，不会受到其他线程的干扰，确保线程的安全。

但是在线程休眠的 10 秒内，通过 stop 方法把线程中止掉，会发现输出结果为 i=1 j=0，也就是代码的前半段 i 自增实现，但是后半段 j 的自增失败，会使线程中的数据出现不一致性，从而同步代码块的保证的原子性的目标没有达成，破坏了线程安全。

正确的线程中止 - interrupt

在介绍了错误的中止方式后，让我们来学习正确的线程中止 - interrupt ：

如果目标线程在调用 Object class 的 wait() 、wait(long) 或 wait(long,int) 方法、join()、join(long,int) 或 sleep(long,int) 方法时阻塞，那么 interrupt 会生效，该线程的中断状态将被清除，抛出 InterruptedException 异常。

如果目标线程是被 IO 或者 NIO 中的 Channel 所阻塞，同样 IO 操作会被中断返回特殊异常值，达到中止线程的目的。

如果以上条件都不满足，则会设置此线程的中断状态。

接下来将 StopThreadDemo 中的 stop 改为 interrupt 来看下运行结果是什么：

java.lang.InterruptedException: sleep interrupted 
  at java.lang.Thread.sleep(Native Method) 
  at com.wupx.thread.StopThread.run(StopThread.java:18) 
i=1 j=1 
1.
2.
3.
4.

可以发现两个变量的自增可以正常执行，保证了执行的数据一致性，interrupt 不会强制中止，将线程直接中断，而是抛出异常通知我们，开发者就可以控制收到异常后的执行逻辑，让整个程序处于线程安全的状态，这是目前 JDK 版本中推荐的 interrupt 方法。

除了 interrupt 的正确方法外，还可以通过标志位的形式来中止线程：

正确的线程中止 - 标志位如果代码程序逻辑中是循环执行的业务，可以在程序的执行中线程代码中增加一个标志位，比如下面代码中在 while 循环中去执行这个程序，通过 flag 去控制程序是否继续执行，如果在外部线程将 flag 修改为 false，那么创建的子线程代码中会收到这个数据的变化，通过这个变量的形式，通知到另一个线程，从而达到控制线程中止的效果。

java.lang.InterruptedException: sleep interrupted 
  at java.lang.Thread.sleep(Native Method) 
  at com.wupx.thread.StopThread.run(StopThread.java:18) 
i=1 j=1 
1.
2.
3.
4.

通过运行代码，得到的结果如下：

运行中 
运行中 
运行中 
程序运行结束 
1.
2.
3.
4.

这种方式受限于线程中所执行的业务逻辑，如果程序中是有可以用来做标志位的条件的话可以用这种方式来做，也是一种正确的线程中止方式。

总结

本文主要学习了线程中止的三种方式：stop、interrupt 以及标志位，大家学会了吗，欢迎留言讨论。