Java中如何停止线程 - Sanarous的博客

Java中如何停止线程

停止线程在 Java 中不像 break 语句一样干脆,需要一些技巧性的处理。停止一个线程意味着在线程处理完任务之前停掉正在做的操作,也就是放弃正在做的操作。虽然这看上去很简单,但是必须要做好一定的防范措施,避免出现一些不可预知的问题。停止一个线程可以使用 Thread.stop()方法,但是最好不要用它,这个方法已经被标注为不安全(unsafe)的,而且已经是被弃用(Deprecated)的,在将来的 Java 版本中,这个方法将不可用或者不被支持。

在 Java 中目前有三种方法可以终止正在运行的线程:

  1. 使用退出标志,使线程可以正常退出,也就是当 run 方法完成后线程终止;
  2. 使用 stop 方法强行终止线程,和 suspend 及 resume 一样,都是作废过期的方法,使用它们将会产生不可预料的错误;
  3. 使用 interrupt 方法中断线程。

其中大多数停止一个线程都是使用 Thread.interrupt()方法,尽管方法的名称是“停止、中止”的意思,但是这个方法不会终止一个正在运行的线程,还需要加入一个判断才可以完成线程的停止。

停止不了的线程

我们首先使用一下 interrupt() 方法来停止线程看看效果。

创建一个 MyThread 类:

1
2
3
4
5
6
7
8
9
public class MyThread extends Thread {
@Override
public void run() {
super.run();
for (int i = 0; i < 50000; i++) {
System.out.println("i = " + (i + 1));
}
}
}

然后写一个 Run 类运行:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Run {
public static void main(String[] args) {
MyThread t = new MyThread();
t.start();
try {
t.sleep(2000);
t.interrupt();
} catch (InterruptedException e) {
System.out.println("main catch");
e.printStackTrace();
}
}
}

结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
...
i = 49990
i = 49991
i = 49992
i = 49993
i = 49994
i = 49995
i = 49996
i = 49997
i = 49998
i = 49999
i = 50000

Process finished with exit code 0

我们发现单纯的使用 interrupt() 方法并不像 for + break 语句那样,马上就停止循环,实际上 interrupt() 方法仅仅是在当前线程中打了一个停止的标记,并不是真正的停止线程。

那么如何停止一个线程呢?

判断线程是否是停止状态

在介绍如何停止线程前,先看一下如何判断一个线程是否是停止状态的,在 Thread 类中提供了两个方法:

  • interrupted() :测试当前线程是否已经中断
  • isInterrupted():测试线程是否已经中断

这两个方法有什么区别呢?

在源码中,我们找到方法的声明:

1
2
3
4
5
6
7
public static boolean interrupted() {
return currentThread().isInterrupted(true);
}

public boolean isInterrupted() {
return isInterrupted(false);
}

发现一个是 static 声明的静态方法,另外一个不是。那么具体使用起来呢?我们测试一下。

将 Run 类中的测试方法修改一下:

1
2
3
4
5
6
7
8
9
10
11
12
public class Run {
public static void main(String[] args) throws InterruptedException {
MyThread t = new MyThread();
t.start();
t.sleep(1000);
t.interrupt();
// Thread.currentThread().interrupt();
System.out.println(" 是否停止 1 ? " + t.interrupted());
System.out.println(" 是否停止 2 ? " + t.interrupted());
System.out.println("end!");
}
}

运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
...
i = 49990
i = 49991
i = 49992
i = 49993
i = 49994
i = 49995
i = 49996
i = 49997
i = 49998
i = 49999
i = 50000
是否停止 1false
是否停止 2false
end!

为什么这里会是 false 呢,不是调用了 interrupt() 方法吗?

我们再回过头来看一下方法解释,原来 interrupt 是指当前线程是否中断,而上述代码的当前线程实际上是 main 线程,这个线程实际上是从未被中断过。

那么我们来中断一下当前线程 main 试一下:

1
2
3
4
5
6
7
8
9
10
11
12
public class Run {
public static void main(String[] args) throws InterruptedException {
MyThread t = new MyThread();
t.start();
t.sleep(1000);
t.interrupt();
Thread.currentThread().interrupt();
System.out.println(" 是否停止 1 ? " + t.interrupted());
System.out.println(" 是否停止 2 ? " + t.interrupted());
System.out.println("end!");
}
}

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
...
i = 49990
i = 49991
i = 49992
i = 49993
i = 49994
i = 49995
i = 49996
i = 49997
i = 49998
i = 49999
i = 50000
是否停止 1true
是否停止 2false
end!

从上面结果来看,确实是判断出了当前线程是否停止的状态,但是为什么一个是 true 一个是 false 呢?我们查看一下官方文档中对 interrupted 方法的解释:

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

文档上已经解释的很详细了, interrupted() 方法具有清除状态的功能,所以第二次是 false。

然后我们再来看一下 isInterrupted() 方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Run {
public static void main(String[] args) {
try {
MyThread t = new MyThread();
t.start();
t.sleep(200);
t.interrupt();
System.out.println(" 是否停止 1 ? " + t.isInterrupted());
System.out.println(" 是否停止 2 ? " + t.isInterrupted());
} catch (InterruptedException e) {
System.out.println("main catch");
e.printStackTrace();
}
System.out.println("end !");
}
}

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
...
i = 47551
i = 47552
i = 47553
i = 47554
i = 47555
是否停止 1true
是否停止 2true
i = 47556
i = 47557
i = 47558
i = 47559
i = 47560
...

从结果可以看到, isInterrupted() 方法并未清除状态标志,所以打印了两个 true。

判断线程状态停止线程

在了解线程停止状态后,就可以在线程中用判断语句判断线程是否处于停止状态,如果是停止状态,让后面的代码不再运行即可,这就是线程终止的基本思路。

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MyThread extends Thread {
@Override
public void run() {
super.run();
for (int i = 0; i < 50000; i++) {
if(interrupted()){
System.out.println("已经是停止状态了,我要退出了!");
break;
}
System.out.println("i = " + (i + 1));
}
}
}

然后创建一个运行类测试一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Run {
public static void main(String[] args) {
MyThread t = new MyThread();
t.start();
try {
Thread.sleep(200);
t.interrupt();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end!");
}
}

运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
...
i = 48288
i = 48289
i = 48290
i = 48291
i = 48292
i = 48293
i = 48294
i = 48295
i = 48296
i = 48297
i = 48298
end!
已经是停止状态了,我要退出了!

这样就可以终止线程的运行了!

在沉睡中停止线程

如果线程在 sleep() 状态下停止线程,会发生什么呢?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class MyThread extends Thread {
@Override
public void run() {
super.run();
System.out.println("run begin");
try {
Thread.sleep(20000);
System.out.println("run end");
} catch (InterruptedException e) {
System.out.println("在沉睡中被停止!进入 catch !" + this.isInterrupted());
e.printStackTrace();
}
}
}

运行类:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Run {
public static void main(String[] args) {
MyThread t = new MyThread();
t.start();
try {
Thread.sleep(200);
t.interrupt();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end!");
}
}

运行结果:

1
2
3
4
5
6
run begin
end!
在沉睡中被停止!进入 catch !false
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at cn.bestzuo.interrupt.MyThread.run(MyThread.java:9)

从结果上看,如果在 sleep 下停止某一线程,会进入 catch 语句块中,并且清除停止状态值,使之变成 false。

暴力停止线程

由于 stop() 方法已经作废,如果强制让线程停止可能使一些清理工作得不到完成,另外一个情况就是对锁定的对象进行了“解锁”,导致数据得不到同步的处理,出现数据不一致的问题。所以这里不再讨论使用 stop() 停止线程。

使用return停止线程

将方法 interrupt 和 return 配合也可以实现停止线程的效果。

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MyThread extends Thread {
@Override
public void run() {
while (true){
if(interrupted()){
System.out.println("停止了!");
return;
}
System.out.println("time = " + System.currentTimeMillis());
}

}
}
1
2
3
4
5
6
7
8
public class Run {
public static void main(String[] args) throws InterruptedException {
MyThread t = new MyThread();
t.start();
Thread.sleep(2000);
t.interrupt();
}
}

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
...
time = 1562831229933
time = 1562831229933
time = 1562831229933
time = 1562831229933
time = 1562831229933
time = 1562831229933
time = 1562831229933
time = 1562831229933
time = 1562831229933
time = 1562831229933
time = 1562831229933
time = 1562831229933
time = 1562831229933
停止了!

可以看到线程也能够停止。

如果这篇文章对您很有帮助,不妨
-------------    本文结束  感谢您的阅读    -------------
0%