如何在Java中优雅的停止线程

ゝ一世哀愁。 2022-12-18 09:59 212阅读 0赞

## 线程 - 停止（Interrupted、isInterrupted） ##

### \-----------------目录直通车------------------ ###

*   *  线程 - 停止（Interrupted、isInterrupted）
     *   *  一、 废弃的停止方法
         *  二、interrupt() 初体验
         *  三、判断线程是否为停止状态
         *  四、 能停止的线程——异常法
         *  五、在 sleep 状态下停止线程

### 一、 废弃的停止方法 ###

很多朋友一看到这个标题就能想到：Thread.stop()。Java中的多线程可不像break语句那么干脆。

stop、suspend、resume 这三个过期作废的方法是不推荐使用的，因为有可能会发生不可预料的结果而且出现错误后还难定位。

这里讲一下为什么不推荐使用Thread.stop()。这个方法是从外面让线程**强制停止**，如果停止的线程持有一个临界锁， 把一个对象置于一个不一致的状态（包含临界、持久化、游离），说白了就是造成数据不一致的结果。

大多数情况下，停止一个线程使用 Thread.interrupt() 方法，但是这个方法不会终止一个正在运行状态的线程，还需要加入一些判断才能完成停止线程。

在Java中有3种方式停止正在运行的线程：

1、使用退出标志，正常退出；

2、使用 stop()， 强行终止；

3、使用 interrupt() 方法，中断线程；

### 二、interrupt() 初体验 ###

一上来就按照下面这种方式运行：

public class ThreadInterrupt { 
        public static void main(String[] args) throws InterruptedException { 
            MyThread myThread = new MyThread();
            myThread.start();
            Thread.sleep(1000);
            myThread.interrupt();
            System.out.println("mrdjun");
        }
    }
    
    class MyThread extends Thread { 
        @Override
        public void run() { 
            super.run();
            for (int i = 0; i < 1000000; i++) { 
                System.out.println("i=" + (i + 1));
            }
        }
    }

发现结果输出了 **1000000** 行，而且 mrdjun 还输出在了中间，说明 interrupt 并没有让线程停下来。

### 三、判断线程是否为停止状态 ###

下面Java提供了两个判断线程是否为停止状态的方法。

public static boolean interrupted() ：使用 Thread.interrupted() 测试当前线程是否已经中断，执行后清楚状态标志值为 false 的功能。

public boolean this.isInterrupted()： 测试 this 关键字所在类的对象是否已经中断，不清楚标志。

public class ThreadInterrupt { 
        public static void main(String[] args) throws InterruptedException { 
            MyThread myThread = new MyThread();
            myThread.start();
            Thread.sleep(1000);
            myThread.interrupt(); // 作用于 myThread 对象
            // isInterrupted 测试当前线程是否已经中断
            System.out.println("线程是否停止？"+myThread.isInterrupted());
            System.out.println("线程是否停止？"+myThread.isInterrupted());
        }
    }

补充一点：也可以使用 Thread.interrupted() 来判断当前线程是否已经中断，因为在 Thread.java 这个类中调用静态static方法的时候，大多数是针对 currentThread() 线程进行操作的。

public class ThreadInterrupt { 
        public static void main(String[] args) throws InterruptedException { 
          	Thread.currentThread().interrupt(); // 作用于 Thread
            // isInterrupted 测试当前线程是否已经中断
            System.out.println("线程是否停止？"+ Thread.interrupted()); // 输出 true
            System.out.println("线程是否停止？"+ Thread.interrupted()); // 输出 false
            System.out.println("END!");
        }
    }

出乎意料的是结果输出不一致，查看官方帮助文档中的 interrupted() 解释：

> 测试当前线程是否已经中断。线程的中断状态由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。

isInterrupted() 的方法声明如下：

public boolean isInterrupted();

很显然，这个方法不是一个static方法，作用于这个方法的对象，如下。

public class ThreadInterrupt { 
        public static void main(String[] args) throws InterruptedException { 
            MyThread myThread = new MyThread();
            myThread.start();
            Thread.sleep(1000);
    	    myThread.interrupt();
            System.out.println("线程是否停止？" + myThread.isInterrupted()); // 输出 true
            System.out.println("线程是否停止？" + myThread.isInterrupted()); // 输出 true
            System.out.println("END!");
        }
    }

综上所述，两者区别如下：

（1）this.interrupted() 测试线程是否已经中断，执行后具有清除状态标志值为false的功能；

（2）this.isInterrupted() 测试线程Thread对象是否已经是中断状态，不清除状态标志；

### 四、 能停止的线程——异常法 ###

在main方法中两秒后调用 Thread 对象的 myThread.interrupt() 方法，在线程中的for循环中加入 if 判断后面的代码是否可以运行。

public class ThreadInterrupt { 
        public static void main(String[] args) throws InterruptedException { 
            MyThread myThread = new MyThread();
            myThread.start();
            Thread.sleep(500);
            myThread.interrupt();
        }
    }
    
    class MyThread extends Thread { 
        @Override
        public void run() { 
            super.run();
            try { 
                for (int i = 0; i < 5000000; i++) { 
                    if (interrupted()) { 
                        System.out.println("线程已经停止");
                        // 退出当前循环，如果为 return; 或 throw new InterruptedException() 则直接退出当前线程
                        throw new InterruptedException();
                    }
                    System.out.println("i=" + (i + 1));
                }
                System.out.println("for循环外面的语句");
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    }

抛出异常方式详情：

public class ThreadInterrupt { 
        public static void main(String[] args) { 
            try { 
                MyThread myThread = new MyThread();
                myThread.start();
                Thread.sleep(1000);
                myThread.interrupt();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    }
    
    class MyThread extends Thread { 
        @Override
        public void run() { 
            super.run();
            try { 
                for (int i = 0; i < 5000000; i++) { 
                    if (interrupted()) { 
                        System.out.println("线程已经停止");
                        throw new InterruptedException();
                    }
                    System.out.println("i=" + (i + 1));
                }
                System.out.println("for循环外面的语句");
            } catch (Exception e) { 
                System.out.println("抛出异常");
                e.printStackTrace();
            }
        }
    }

通过下面的运行结果可以看出，线程终于被正确的停止了。

i=312961
    i=312962
    线程已经停止
    抛出异常
    java.lang.InterruptedException
    	at com.fun.async.test.class03.MyThread.run(ThreadInterrupt.java:34)

### 五、在 sleep 状态下停止线程 ###

public class SleepThreadInterrupt { 
        public static void main(String[] args) { 
            try { 
                MyThread thread = new MyThread();
                thread.start();
                Thread.sleep(200); // 先sleep 在调用 interrupt
                thread.interrupt();
                System.out.println("complete!");
            } catch (InterruptedException e) { 
                System.out.println("main catch");
                e.printStackTrace();
            }
        }
    
        static class MyThread extends Thread{ 
            @Override
            public void run() { 
                super.run();
                try { 
                    System.out.println("run start ...");
                    Thread.sleep(200000);
                    System.out.println("run end!");
                } catch (InterruptedException e) { 
                    System.out.println("在sleep中停止，进入catch！"+this.isInterrupted());
                    e.printStackTrace();
                }
            }
        }
    }

从下面的输出结果来看，如果线程在 sleep 状态下停止，则该线程会进入 catch 语句，并且清除停止状态值，变成false。

run start ...
    complete!
    在sleep中停止，进入catch！false
    java.lang.InterruptedException: sleep interrupted
    	at java.lang.Thread.sleep(Native Method)
    	at com.fun.async.test.class03.SleepThreadInterrupt$MyThread.run(SleepThreadInterrupt.java:26)