转载

Java中如何停止线程

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

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

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

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

停止不了的线程

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

创建一个 MyThread 类：

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 类运行：

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();
        }
    }
}

结果如下：

...
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()：测试线程是否已经中断

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

在源码中，我们找到方法的声明：

public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}

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

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

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

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!");
    }
}

运行结果如下：

...
i = 49990
i = 49991
i = 49992
i = 49993
i = 49994
i = 49995
i = 49996
i = 49997
i = 49998
i = 49999
i = 50000
 是否停止 1 ？ false
 是否停止 2 ？ false
end!

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

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

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

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!");
    }
}

运行结果：

...
i = 49990
i = 49991
i = 49992
i = 49993
i = 49994
i = 49995
i = 49996
i = 49997
i = 49998
i = 49999
i = 50000
 是否停止 1 ？ true
 是否停止 2 ？ false
end!

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

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

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

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

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 !");
    }
}

运行结果：

...
i = 47551
i = 47552
i = 47553
i = 47554
i = 47555
 是否停止 1 ？ true
 是否停止 2 ？ true
i = 47556
i = 47557
i = 47558
i = 47559
i = 47560
...

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

判断线程状态停止线程

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

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));
        }
    }
}

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

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!");
    }
}

运行结果如下：

...
i = 48288
i = 48289
i = 48290
i = 48291
i = 48292
i = 48293
i = 48294
i = 48295
i = 48296
i = 48297
i = 48298
end!
已经是停止状态了，我要退出了！

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

在沉睡中停止线程

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

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();
        }
    }
}

运行类：

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!");
    }
}

运行结果：

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 配合也可以实现停止线程的效果。

public class MyThread extends Thread {
    @Override
    public void run() {
        while (true){
            if(interrupted()){
                System.out.println("停止了！");
                return;
            }
            System.out.println("time = " + System.currentTimeMillis());
        }

    }
}

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

运行结果：

...
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
停止了！

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

原文 https://bestzuo.cn/posts/694670355.html

正文到此结束