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

拼搏现实的明天。 2021-12-10 22:43 167阅读 0赞

停止线程是在多线程开发中很重要的技术点，掌握此技术可以对线程的停止进行有效的处理。停止线程在 [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 的整数，代码如下：

1.  package ch14;
2.  public class MyThread13 extends Thread
3.  \{
4.  @Override
5.  public void run()
6.  \{
7.  super.run();
8.  for (int i=0;i<10000;i++)
9.  \{
10. System.out.println("i="+(i+1));
11. \}
12. \}
13. \}

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

1.  package ch14;
2.  public class Test17
3.  \{
4.  public static void main(String\[\] args)
5.  \{
6.  try
7.  \{
8.  MyThread13 thread=new MyThread13(); //创建MyThread13线程类实例
9.  thread.start(); //启动线程
10. Thread.sleep(100); //延时100毫秒
11. thread.interrupt(); //停止线程
12. \}
13. catch(InterruptedException e)
14. \{
15. System.out.println("main catch");
16. e.printStackTrace();
17. \}
18. \}
19. \}

主线程的运行结果如下所示。从中可以看到，虽然在延时 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 线程类的代码如下：

1.  package ch14;
2.  public class MyThread14 extends Thread
3.  \{
4.  @Override
5.  public void run()
6.  \{
7.  super.run();
8.  for(int i=0;i<10000;i++)
9.  \{
10. System.out.println("i="+(i+1));
11. \}
12. \}
13. \}

主线程的代码如下：

1.  package ch14;
2.  public class Test18
3.  \{
4.  public static void main(String\[\] args)
5.  \{
6.  try
7.  \{
8.  MyThread14 thread=new MyThread14();
9.  thread.start(); //启动线程
10. Thread.sleep(100); //延时100毫秒
11. thread.interrupt(); //停止线程
12. //Thread.currentThread().interrupt();
13. System.out.println("是否停止1？="+thread.interrupted());
14. System.out.println("是否停止2？="+thread.interrupted());
15. \}
16. catch(InterruptedException e)
17. \{
18. System.out.println("main catch");
19. e.printStackTrace();
20. \}
21. System.out.println("end!");
22. \}
23. \}

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

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

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

1.  thread.interrupt();

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

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

从控制台打印的结果来看，线程并未停止，这也就证明了 interrupted() 方法的解释：测试当前线程是否已经中断。这个“当前线程”是 main，它从未中断过，所以打印的结果是两个 false。  
  
那么如何使 main 线程产生中断效果呢？再来看一下如下的代码：

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

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

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

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

public boolean isInterrupted()

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

1.  package ch14;
2.  public class Test18
3.  \{
4.  public static void main(String\[\] args)
5.  \{
6.  try
7.  \{
8.  MyThread14 thread=new MyThread14();
9.  thread.start();
10. Thread.sleep(100);
11. thread.interrupt();
12. System.out.println("是否停止1？="+thread.isInterrupted());
13. System.out.println("是否停止2？="+thread.isInterrupted());
14. \}
15. catch(InterruptedException e)
16. \{
17. System.out.println("main catch");
18. e.printStackTrace();
19. \}
20. System.out.println("end!");
21. \}
22. \}

程序运行结果如下所示。

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() 方法判断线程是否停止。

1.  package ch14;
2.  public class MyThread15 extends Thread
3.  \{
4.  @Override
5.  public void run()
6.  \{
7.  super.run();
8.  for(int i=0;i<500000;i++)
9.  \{
10. if(this.interrupted())
11. \{ //如果当前线程处于停止状态
12. System.out.println("已经是停止状态了!我要退出了!");
13. break;
14. \}
15. System.out.println("i="+(i+1));
16. \}
17. \}
18. \}

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

1.  package ch14;
2.  public class Test19
3.  \{
4.  public static void main(String\[\] args)
5.  \{
6.  try
7.  \{
8.  MyThread15 thread=new MyThread15();
9.  thread.start(); //启动线程
10. Thread.sleep(2000); //延时2000毫秒
11. thread.interrupt(); //停止线程
12. \}
13. catch(InterruptedException e)
14. \{ //捕捉线程停止异常
15. System.out.println("main catch");
16. e.printStackTrace();
17. \}
18. System.out.println("end!"); //主线程结束时输出
19. \}
20. \}

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

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

从程序执行的结果可以看到，在示例中虽然停止了线程，但如果 for 语句下面还有语句，还是会继续运行的。  
  
下面对 MyThread15 线程进行修改，如下所示是 run() 方法的代码：

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

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

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

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

1.  public void run()
2.  \{
3.  super.run();
4.  try
5.  \{
6.  for(int i=0;i<500000;i++)
7.  \{
8.  if(this.interrupted())
9.  \{
10. System.out.println("已经是停止状态了!我要退出了!");
11. throw new InterruptedException();
12. \}
13. System.out.println("i=" + (i + 1));
14. \}
15. System.out.println("我在for下面");
16. \}
17. catch(InterruptedException e)
18. \{
19. System.out.println("进MyThread15.java类run方法中的catch了！");
20. e.printStackTrace();
21. \}
22. \}

再次运行程序，当线程处于停止状态后，如果 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 线程类代码。

1.  package ch14;
2.  public class MyThread16 extends Thread
3.  \{
4.  @Override
5.  public void run()
6.  \{
7.  super.run();
8.  try
9.  \{
10. System.out.println("run begin");
11. Thread.sleep(200000);
12. System.out.println("run end");
13. \}
14. catch(InterruptedException e)
15. \{
16. System.out.println("在休眠中被停止!进入catch!"+this.isInterrupted());
17. e.printStackTrace();
18. \}
19. \}
20. \}

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

1.  package ch14;
2.  public class Test20
3.  \{
4.  public static void main(String\[\] args)
5.  \{
6.  try
7.  \{
8.  MyThread16 thread=new MyThread16();
9.  thread.start();
10. Thread.sleep(200);
11. thread.interrupt();
12. \}
13. catch(InterruptedException e)
14. \{
15. System.out.println("main catch");
16. e.printStackTrace();
17. \}
18. System.out.println("end!");
19. \}
20. \}

在上述代码中启动 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 线程类代码如下：

1.  package ch14;
2.  public class MyThread17 extends Thread
3.  \{
4.  @Override
5.  public void run()
6.  \{
7.  super.run();
8.  try
9.  \{
10. for(int i=0;i<1000;i++)
11. \{
12. System.out.println("i="+(i+1));
13. \}
14. System.out.println("run begin");
15. Thread.sleep(200);
16. System.out.println("run end");
17. \}
18. catch(InterruptedException e)
19. \{
20. System.out.println("先停止，再遇到了sleep!进入catch!");
21. e.printStackTrace();
22. \}
23. \}
24. \}

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

1.  package ch14;
2.  public class Test21
3.  \{
4.  public static void main(String\[\] args)
5.  \{
6.  MyThread17 thread=new MyThread17();
7.  thread.start();
8.  thread.interrupt();
9.  System.out.println("end!");
10. \}
11. \}

在上述代码中启动 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() 停止线程的方法。

1.  package ch14;
2.  public class MyThread18 extends Thread
3.  \{
4.  private int i=0;
5.  @Override
6.  public void run()
7.  \{
8.  try
9.  \{
10. while (true)
11. \{
12. i++;
13. System.out.println("i=" + i);
14. Thread.sleep(1000);
15. \}
16. \}
17. catch(InterruptedException e)
18. \{
19. //TODO Auto-generated catch block
20. e.printStackTrace();
21. \}
22. \}
23. \}

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

1.  package ch14;
2.  public class Test22
3.  \{
4.  @SuppressWarnings("deprecation")
5.  public static void main(String\[\] args)
6.  \{
7.  try
8.  \{
9.  MyThread18 thread=new MyThread18();
10. thread.start();
11. Thread.sleep(8000);
12. thread.stop();
13. \}
14. catch(InterruptedException e)
15. \{
16. // TODO Auto-generated catch block
17. e.printStackTrace();
18. \}
19. \}
20. \}

如上述代码所示，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 的实体类，该类代码如下：

1.  package ch14;
2.  public class SynchronizedObject
3.  \{
4.  private String username="root";
5.  private String password="root";
6.  public String getUsername()
7.  \{
8.  return username;
9.  \}
10. public void setUsername(String username)
11. \{
12. this.username=username;
13. \}
14. public String getPassword()
15. \{
16. return password;
17. \}
18. public void setPassword(String password)
19. \{
20. this.password=password;
21. \}
22. synchronized public void printString(String username,String password)
23. \{
24. try
25. \{
26. this.username=username;
27. Thread.sleep(100000);
28. this.password=password;
29. \}
30. catch(InterruptedException e)
31. \{
32. e.printStackTrace();
33. \}
34. \}
35. \}

如上述代码所示，SynchronizedObject 类包含用户名和密码两个成员，printString() 方法用于对这两个成员进行赋值，但是在设置密码之前有一个休眠时间。  
  
下面编写一个线程来对 SynchronizedObject 类进行实例化，并调用 printString() 方法。线程代码如下：

1.  package ch14;
2.  public class MyThread19 extends Thread
3.  \{
4.  private SynchronizedObject object;
5.  public MyThread19(SynchronizedObject object)
6.  \{
7.  super();
8.  this.object=object;
9.  \}
10. @Override
11. public void run()
12. \{
13. object.printString("admin","123456");
14. \}
15. \}

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

1.  package ch14;
2.  public class Test23
3.  \{
4.  public static void main(String\[\] args)
5.  \{
6.  try
7.  \{
8.  SynchronizedObject object=new SynchronizedObject();
9.  MyThread19 thread=new MyThread19(object);
10. thread.start();
11. Thread.sleep(500);
12. thread.stop();
13. System.out.println("用户名："+object.getUsername());
14. System.out.println("密码："+object.getPassword());
15. \}
16. catch(InterruptedException e)
17. \{
18. e.printStackTrace();
19. \}
20. \}
21. \}

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

用户名：admin
    密码：root

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

## 使用 return 停止线程 ##

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

例 7

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

1.  package ch14;
2.  public class MyThread20 extends Thread
3.  \{
4.  @Override
5.  public void run()
6.  \{
7.  while (true)
8.  \{
9.  if (this.isInterrupted())
10. \{
11. System.out.println("停止了!");
12. return;
13. \}
14. System.out.println("timer="+System.currentTimeMillis());
15. \}
16. \}
17. \}

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

1.  package ch14;
2.  public class Test24
3.  \{
4.  public static void main(String\[\] args) throws InterruptedException
5.  \{
6.  MyThread20 t=new MyThread20();
7.  t.start();
8.  Thread.sleep(2000);
9.  t.interrupt();
10. \}
11. \}

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

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

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

[Java]: http://c.biancheng.net/java/