停止线程

发表于 | 分类于 ，

有三种方式来停止线程：
1. 正常执行 run()方法，run()方法结束后，线程终止。
2. 使用 stop 方法强行终止线程，不推荐使用，会造成不可预料的后果。
3. 使用 interrupt 方法中断线程。

现在对于第三种方式来详细了解一下。
在Java的SDK中，Thread.java类提供了两种方法：
1) this.interrupted()：测试当前线程是否已经中断。
2) this.isinterrupted()：测试线程是否已经中断。

interrupted()是静态方法，所以我们用Thread.interrupted()方法表示，它调用的是currentThread().isInterrupted(true)方法，即说明是返回当前线程的是否已经中断的状态值，而且有清理中断状态的机制。而isInterrupted()是一个实例方法，所以我们用this.isInterrupted()方法表示，它调用的是isInterrupted(false)方法，意思是返回线程是否已经中断的状态值，与Thread.interrupted()方法相反，它没有清理中断状态的机制。

二者的区别在于：

interrupted()是static方法，调用的时候要用Thread.interrupted()，而isInterrupted()是实例方法，调用时要用线程的实例调用；
Thread.interrupted()：测试当前线程是否已经是中断状态，执行后具有将状态标志清除为false的功能；
this.isInterrupted()：测试线程Thread对象是否已经是中断状态，但不清除状态标志。

线程的停止——抛异常法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class MyThread4 extends Thread {
    @Override
    public void run() {
        super.run();
        try {
            for (int i = 0; i < 50000; i++) {
                if (this.isInterrupted()) {
                    System.out.println( "线程已经结束，我要退出" );
//                    return;   //这是return法停止线程
                    throw new InterruptedException();  //抛异常法停止线程
                }
                System.out.println( "i=" + (i + 1) );
            }
            System.out.println( "我是for下面的语句，我被执行说明线程没有真正结束" );
        } catch (InterruptedException e) {
            System.out.println( "进入MyThread.java类中run方法的catch异常了" );
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
public static void main(String[] args) {
        try {
            MyThread4 myThread4 = new MyThread4();
            myThread4.start();
            Thread.sleep( 20);
            myThread4.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
15
16
17
18
19
20
21
22
public void run() {
        super.run();
        try {
            System.out.println( "begin run" );
            Thread.sleep( 500 );
            System.out.println( "begin end" );
        } catch (InterruptedException e) {
            System.out.println("在沉睡中终止");
            e.printStackTrace();
        }
    }
 public static void main(String[] args) {
        try {
            MyThread5 thread5 = new MyThread5();
            thread5.start();
            Thread.sleep( 20 );
            thread5.interrupt();
        } catch (InterruptedException e) {
            System.out.println( "main catch" );
            e.printStackTrace();
        }
    }

其实就是在执行中断操作前，执行一个sleep()方法。那为什么这样就能停止线程呢？
看这句话：当线程处于下面的状况时（（1）如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个InterruptedException异常。这个时候，我们可以通过捕获InterruptedException异常来终止线程的执行，具体可以通过return等退出或改变共享变量的值使其退出。）
这样看来，其实这两个方法都属于抛异常法，一个是主动抛出异常，一个是调用sleep()后，被系统抛出异常。

0%