Java停止（终止）线程详解版

停止线程是在多线程开发中很重要的技术点，掌握此技术可以对线程的停止进行有效的处理。停止线程在 Java 语言中并不像 break 语句那样干脆，需要一些技巧性的处理。

使用 Java 内置支持多线程的类设计多线程应用是很常见的事情，然而，多线程给开发人员带来了一些新的挑战，如果处理不好就会导致超出预期的行为并且难以定位错误。

本节将讨论如何更好地停止一个线程。停止一个线程意味着在线程处理完任务之前停掉正在做的操作，也就是放弃当前的操作。虽然这看起来非常简单，但是必须做好防范措施，以便达到预期的效果。

停止一个线程可以使用 Threadstop() 方法，但最好不用它。虽然它确实可以停止一个正在运行的线程，但是这个方法是不安全的，而且已被弃用作废了，在将来的 Java 版本中，这个方法将不可用或不被支持。

大多数停止一个线程的操作使用 Thread.interrupt() 方法，尽管方法的名称是“停止，中止”的意思，但这个方法不会终止一个正在运行的线程，还需要加入一个判断才可以完成线程的停止。关于此知识点在后面有专门的章节进行介绍。

在 Java 中有以下 3 种方法可以终止正在运行的线程：

1. 使用退出标识，使线程正常退出，也就是当 run() 方法完成后线程终止。
2. 使用 stop() 方法强行终止线程，但是不推荐使用这个方法，因为 stop() 和 suspend() 及 resume() 一样，都是作废过期的方法，使用它们可能产生不可预料的结果。
3. 使用 interrupt() 方法中断线程。

停止不了的线程

interrupt() 方法的作用是用来停止线程，但 intermpt() 方法的使用效果并不像循环结构中 break 语句那样，可以马上停止循环。调用 intermpt() 方法仅仅是在当前线程中打了一个停止的标记，并不是真的停止线程。

例 1

下面通过一个案例演示 interrupt() 方法停止线程的用法。案例用到的线程非常简单，仅仅是实现输出从 1~10000 的整数，代码如下：

package ch14;
public class MyThread13 extends Thread
{
    @Override 
    public void run()
    { 
        super.run(); 
        for (int i=0;i<10000;i++)
        { 
            System.out.println("i="+(i+1)); 
        } 
    } 
}

在调用 intermpt() 方法停止 MyThread13 线程之前，首先进行了一个 100 毫秒的休眠。主线程的代码如下：

package ch14;
public class Test17
{
    public static void main(String[] args)
    { 
        try
        { 
            MyThread13 thread=new MyThread13();      //创建MyThread13线程类实例
            thread.start();    //启动线程
            Thread.sleep(100);    //延时100毫秒
            thread.interrupt();    //停止线程
        }
        catch(InterruptedException e)
        { 
            System.out.println("main catch"); 
            e.printStackTrace(); 
        } 
    }
}

主线程的运行结果如下所示。从中可以看到，虽然在延时 100 毫秒后调用 intermpt() 方法停止了 thread 线程，但是该线程仍然执行完成输出 10000 行信息。

i=1
i=2
...
i=9999
i=10000

判断线程是不是停止状态

在介绍如何停止线程的知识点前，先来看一下如何判断线程的状态是不是停止的。在 Java 的 SDK 中，Thread.java 类里提供了两种方法。

1. this.interrupted()：测试当前线程是否已经中断。
2. this.islnterrupted()：测试线程是否已经中断。

那么这两个方法有什么区别呢？先来看看 this.intermpted() 方法的解释：测试当前线程是否已经中断，当前线程是指运行 this.interrupted() 方法的线程。为了对此方法有更深入的了解，下面通过一个案例进行说明。

例 2

假设 MyThread14 线程类的代码如下：

package ch14;
public class MyThread14 extends Thread
{
    @Override 
    public void run()
    { 
        super.run(); 
        for(int i=0;i<10000;i++)
        { 
            System.out.println("i="+(i+1)); 
        } 
    } 
}

主线程的代码如下：

package ch14;
public class Test18
{
    public static void main(String[] args)
    {
        try
        {
            MyThread14 thread=new MyThread14();
            thread.start();    //启动线程
            Thread.sleep(100);    //延时100毫秒
            thread.interrupt();    //停止线程
            //Thread.currentThread().interrupt();
            System.out.println("是否停止1？="+thread.interrupted());
            System.out.println("是否停止2？="+thread.interrupted());
        }
        catch(InterruptedException e)
        {
            System.out.println("main catch");
            e.printStackTrace();
        }
        System.out.println("end!");
    }
}

程序运行后的结果如下所示。

i=1
i=2
...
i=9999
i=10000
是否停止1？=false
是否停止2？=false
end!

在主线程中是在 thread 对象上调用以下代码来停止 thread 对象所代表的线程。

thread.interrupt();

后面又使用以下代码来判断 thread 对象所代表的线程是否停止。

System.out.println("是否停止 1 ? ="+thread.interrupted());
System.out.println("是否停止 2 ? ="+thread.interrupted());

从控制台打印的结果来看，线程并未停止，这也就证明了 interrupted() 方法的解释：测试当前线程是否已经中断。这个“当前线程”是 main，它从未中断过，所以打印的结果是两个 false。

那么如何使 main 线程产生中断效果呢？再来看一下如下的代码：

public static void main(String[] args)
{
    Thread.currentThread().interrupt();
    System.out.println(" 是否停止 1 ? ="+Thread.interrupted());
    System.out.println(" 是否停止 2 ? ="+Thread.interrupted());
    System.out.println("end!");
}

程序运行后的结果如下所示。

是否停止 1 ? =true
是否停止 2 ? =false end!

从上述的结果来看，intermpted() 方法的确用来判断出当前线程是不是停止状态。但为什么第二个布尔值是 false 呢？查看一下官方帮助文档中对 interrupted() 方法的解释如下（斜体显示）：
测试当前线程是否已经中断。线程的中断状态由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。

文档已经解释得很详细，intermpted() 方法具有清除状态的功能，所以第二次调用 interrupted() 方法返回的值是 false。

介绍完 interrupted() 方法后再来看一下 isInterrupted() 方法。isInterrupted() 方法的声明如下：

public boolean isInterrupted()

从声明中可以看出 isIntermpted() 方法不是 static 的。仍然以 MyThread14 线程为例，这里使用 isInterrupted() 方法来判断线程是否停止，具体代码如下：

package ch14;
public class Test18
{
    public static void main(String[] args)
    {
        try
        {
            MyThread14 thread=new MyThread14();
            thread.start();
            Thread.sleep(100);
            thread.interrupt();
            System.out.println("是否停止1？="+thread.isInterrupted());
            System.out.println("是否停止2？="+thread.isInterrupted());
        }
        catch(InterruptedException e)
        {
            System.out.println("main catch");
            e.printStackTrace();
        }
        System.out.println("end!");
    }
}

程序运行结果如下所示。

i=498
是否停止1？=true
i=499
是否俜止2？=true
i=500
end!
i=501
i=502

从程序的运行结果中可以看到，isInterrupted() 方法并未清除状态标识，所以打印了两个 true。经过上面示例的验证总结一下这两个方法。

1. this.interrupted()：测试当前线程是否已经是中断状态，执行后具有将状态标识清除为 false 的功能。
2. this.islnterrupted()：测试线程 Thread 对象是否已经是中断状态，但不清除状态标识。

异常法停止线程

有了前面学习过的知识，就可在线程中用 for 语句来判断线程是否为停止状态，如果是停止状态，则后面的代码不再运行。

例 3

下面的线程类 MyThread15 演示了在线程中使用 for 循环，并在循环中调用 intermpted() 方法判断线程是否停止。

package ch14;
public class MyThread15 extends Thread
{
    @Override
    public void run()
    {
        super.run();
        for(int i=0;i<500000;i++)
        {
            if(this.interrupted())
            {    //如果当前线程处于停止状态
                System.out.println("已经是停止状态了!我要退出了!");
                break;
            }
            System.out.println("i="+(i+1));
        }
    }
}

接下来编写启动 MyThread15 线程的代码，主线程代码如下：

package ch14;
public class Test19
{
    public static void main(String[] args)
    {
        try
        { 
            MyThread15 thread=new MyThread15(); 
            thread.start();    //启动线程
            Thread.sleep(2000);    //延时2000毫秒
            thread.interrupt();    //停止线程
        }
        catch(InterruptedException e)
        {    //捕捉线程停止异常
            System.out.println("main catch"); 
            e.printStackTrace(); 
        } 
        System.out.println("end!");    //主线程结束时输出
    }
}

上述代码启动 MyThread15 线程后延时 2000 毫秒，之后将线程停止。为避免主线程崩溃使用 catch 捕捉了 InterruptedException 异常，此时会输出“main catch”。在主线程执行结束后会输出“end!”。程序执行的输出结果如下所示。

......
i=271597
i=271598
已经是停止状态了!我要退出了!
end!

从程序执行的结果可以看到，在示例中虽然停止了线程，但如果 for 语句下面还有语句，还是会继续运行的。

下面对 MyThread15 线程进行修改，如下所示是 run() 方法的代码：

public void run()
{ 
    super.run(); 
    for(int i=0;i<500000;i++)
    { 
        if(this.interrupted())
        { 
            System.out.println("已经是停止状态了!我要退出了!"); 
            break; 
        } 
        System.out.println("i="+(i+1)); 
    } 
    System.out.println("我被输出，如果此代码是for又继续运行，线程并未停止！"); 
}

此时的运行效果如下所示，说明线程仍然在继续运行。

......
i=233702
i=233703
end!
已经是停止状态了!我要退出了!
我被输出，如果此代码是for又继续运行，线程并未停止！

那该如何解决线程停止后，语句仍然继续运行的问题呢？解决的办法是在线程中捕捉线程停止异常，如下为修改后的 run() 方法代码。

public void run()
{ 
    super.run(); 
    try
    { 
        for(int i=0;i<500000;i++)
        { 
            if(this.interrupted())
            { 
                System.out.println("已经是停止状态了!我要退出了!"); 
                throw new InterruptedException(); 
            } 
            System.out.println("i=" + (i + 1)); 
        } 
        System.out.println("我在for下面"); 
    }
    catch(InterruptedException e)
    { 
        System.out.println("进MyThread15.java类run方法中的catch了！"); 
        e.printStackTrace(); 
    } 
}

再次运行程序，当线程处于停止状态后，如果 for 循环中的代码继续执行将会拋出 InterruptedException 异常，运行结果如下所示。

......
i=251711
i=251712
i=251713
已经是停止状态了!我要退出了!
end!
进MyThread15.java类run方法中的catch了！
java.lang.InterruptedException
    at text.MyThread.run(MyThread.java:16)

在休眠中停止

如果线程在 sleep() 状态下停止，会是什么效果呢？

例 4

下面通过一个案例来演示这种情况。如下所示为案例中使用的 MyThread16 线程类代码。

package ch14;
public class MyThread16 extends Thread
{
    @Override
    public void run()
    {
        super.run();
        try
        {
            System.out.println("run begin");
            Thread.sleep(200000);
            System.out.println("run end");
        }
        catch(InterruptedException e)
        {
            System.out.println("在休眠中被停止!进入catch!"+this.isInterrupted());
            e.printStackTrace();
        }
    }
}

调用 MyThread16 线程的主线程代码如下：

package ch14;
public class Test20
{
    public static void main(String[] args)
    {
        try
        {
            MyThread16 thread=new MyThread16();
            thread.start();
            Thread.sleep(200);
            thread.interrupt();
        }
        catch(InterruptedException e)
        {
            System.out.println("main catch");
            e.printStackTrace();
        }
        System.out.println("end!");
    }
}

在上述代码中启动 MyThread16 线程后休眠了 200 毫秒，之后调用 interrupt() 方法停止线程，运行结果如下所示。

run begin
end!
在休眠中被停止!进入catch!false
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at text.MyThread.run(MyThread.java:12)

从运行结果来看，如果在休眠状态下停止某一线程则会拋出进入 InterruptedException 异常，所以会进入 catch 语句块清除停止状态值，使之变成 false。

例 5

这个示例是先休眠再停止线程，下面再编写一个案例来演示先停止再休眠线程的情况。案例使用的 MyThread17 线程类代码如下：

package ch14;
public class MyThread17 extends Thread
{
    @Override
    public void run()
    {
        super.run();
        try
        {
            for(int i=0;i<1000;i++)
            {
                System.out.println("i="+(i+1));
            }
            System.out.println("run begin");
            Thread.sleep(200);
            System.out.println("run end");
        }
        catch(InterruptedException e)
        {
            System.out.println("先停止，再遇到了sleep!进入catch!");
            e.printStackTrace();
        }
    }
}

使用 MyThread17 线程的主线程代码如下：

package ch14;
public class Test21
{
    public static void main(String[] args)
    {
        MyThread17 thread=new MyThread17();
        thread.start();
        thread.interrupt();
        System.out.println("end!");
    }
}

在上述代码中启动 MyThread17 线程后没有进行延时，马上调用 interrupt() 方法进行停止线程，但是在 MyThread17 线程中有一个 200 毫秒的延时。运行程序后，首先会看到下所示的输出，说明主线程执行完毕。

end!
i=1
i=2
i=3
i=4
i=5
i=6
......

稍等片刻后，将会看到如下所示的异常，说明线程停止了。

......
i=999
i=1000
run begin
先停止，再遇到了sleep!进入catch!
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at text.MyThread.run(MyThread.java:16)

强制停止线程

调用 stop() 方法可以在任意情况下强制停止一个线程。下面通过一个案例来演示 stop() 停止线程的方法。

package ch14;
public class MyThread18 extends Thread
{
    private int i=0;
    @Override
    public void run()
    {
        try
        {
            while (true)
            {
                i++;
                System.out.println("i=" + i);
                Thread.sleep(1000);
            }
        }
        catch(InterruptedException e)
        {
            //TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

如上述代码所示，MyThread18 线程中包含一个死循环，该循环每隔 1000 毫秒执行一次，每次将 i 的值递增 1 并输出。

调用 MyThread18 线程的主线程代码如下：

package ch14;
public class Test22
{
    @SuppressWarnings("deprecation")
    public static void main(String[] args)
    {
        try
        {
            MyThread18 thread=new MyThread18();
            thread.start();
            Thread.sleep(8000);
            thread.stop();
        }
        catch(InterruptedException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

如上述代码所示，MyThread18 线程在启动后有一个 8000 毫秒的延时，在这段时间内会循环 9 次，之后 stop() 方法被执行从而线程停止。运行后的输出如下所示。

i=1
i=2
i=3
i=4
i=5
i=6
i=7
i=8
i=9

注意：调用 stop() 方法时会抛出 java.lang.ThreadDeath 异常，但在通常情况下，此异常不需要显式地捕捉。

释放锁的不良后果

从 JDK 1.6 以后 stop() 方法已经被作废，因为如果强制让线程停止则有可能使一些清理性的工作得不到完成。另外一个情况就是对锁定的对象进行了“解锁”，导致数据得不到同步的处理，出现数据不一致的问题。

使用 stop() 释放锁将会给数据造成不一致性的结果。如果出现这样的情况，程序处理的数据就有可能遭到破坏，最终导致程序执行的流程错误，一定要特别注意。

例 6

下面通过一个案例来演示这种情况。案例使用了一个名为 SynchronizedObject 的实体类，该类代码如下：

package ch14;
public class SynchronizedObject
{
    private String username="root";
    private String password="root";
    public String getUsername()
    {
        return username;
    }
    public void setUsername(String username)
    {
        this.username=username;
    }
    public String getPassword()
    {
        return password;
    }
    public void setPassword(String password)
    {
        this.password=password;
    }
    synchronized public void printString(String username,String password)
    {
        try
        {
            this.username=username;
            Thread.sleep(100000);
            this.password=password;
        }
        catch(InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

如上述代码所示，SynchronizedObject 类包含用户名和密码两个成员，printString() 方法用于对这两个成员进行赋值，但是在设置密码之前有一个休眠时间。

下面编写一个线程来对 SynchronizedObject 类进行实例化，并调用 printString() 方法。线程代码如下：

package ch14;
public class MyThread19 extends Thread
{
    private SynchronizedObject object;
    public MyThread19(SynchronizedObject object)
    {
        super();
        this.object=object;
    }
    @Override
    public void run()
    {
        object.printString("admin","123456");
    }
}

接下来编写主线程代码如下：

package ch14;
public class Test23
{
    public static void main(String[] args)
    { 
        try
        { 
            SynchronizedObject object=new SynchronizedObject(); 
            MyThread19 thread=new MyThread19(object); 
            thread.start(); 
            Thread.sleep(500); 
            thread.stop(); 
            System.out.println("用户名："+object.getUsername());
            System.out.println("密码："+object.getPassword()); 
        }
        catch(InterruptedException e)
        { 
            e.printStackTrace();
        } 
    } 
}

在上述代码中创建一个 SynchronizedObject 类实例，并将该实例作为参数传递给 MyThread19 线程。MyThread19 线程启动后将立即调用 object.printString('fadminn,"123456") 方法，而在 printString() 方法内有一个较长时间的休眠。该休眠时间大于主线程的休眠时间，所以主线程会继续往下执行，当执行到 stop() 方法时线程被强制停止。

程序最后的运行结果如下所示。

用户名：admin
密码：root

由于 stop() 方法已经在中被标明是“作废/过期”的方法，显然它在功能上具有缺陷，所以不建议在程序中使用 stop() 方法。

使用 return 停止线程

除了上面介绍的方法外，还可以将 intermpt() 方法与 return 结合使用来实现停止线程的效果。

例 7

下面通过一个案例来演示这种情况。如下所示为案例中使用 MyThread20 线程类的代码。

package ch14;
public class MyThread20 extends Thread
{
    @Override
    public void run()
    {
        while (true)
        {
            if (this.isInterrupted())
            {
                System.out.println("停止了!");
                return;
            }
            System.out.println("timer="+System.currentTimeMillis());
        }
    }
}

调用 MyThread20 线程的主线程代码如下：

package ch14;
public class Test24
{
    public static void main(String[] args) throws InterruptedException
    {
        MyThread20 t=new MyThread20();
        t.start();
        Thread.sleep(2000);
        t.interrupt();
    }
}

程序执行后的结果如下所示。

......
timer=1540977194784
timer=1540977194784
timer=1540977194784
timer=1540977194784
timer=1540977194784
停止了!

从程序的执行结果中可以看到成功停止了线程，不过还是建议使用“拋异常”的方法来实现线程的停止，因为在 catch 块中还可以将异常向上拋，使线程停止的事件得以传播。