2. 程式人生 > >如何正確地停止一個執行緒？

如何正確地停止一個執行緒？

阿新 • • 發佈：2019-01-14

停止一個執行緒意味著在任務處理完任務之前停掉正在做的操作，也就是放棄當前的操作。停止一個執行緒可以用Thread.stop()方法，但最好不要用它。雖然它確實可以停止一個正在執行的執行緒，但是這個方法是不安全的，而且是已被廢棄的方法。
在java中有以下3種方法可以終止正在執行的執行緒：

  1. 使用退出標誌，使執行緒正常退出，也就是當run方法完成後執行緒終止。
  2. 使用stop方法強行終止，但是不推薦這個方法，因為stop和suspend及resume一樣都是過期作廢的方法。
  3. 使用interrupt方法中斷執行緒。
1. 停止不了的執行緒

interrupt()方法的使用效果並不像for+break語句那樣，馬上就停止迴圈。呼叫interrupt方法是在當前執行緒中打了一個停止標誌，並不是真的停止執行緒。

public class MyThread extends Thread {
    public void run(){
        super.run();
        for(int i=0; i<500000; i++){
            System.out.println("i="+(i+1));
        }
    }
}

public class Run {
    public static void main(String args[]){
        Thread thread = new MyThread();
        thread.start();
        try {
            Thread.sleep(2000);
            thread.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

輸出結果：

...
i=499994
i=499995
i=499996
i=499997
i=499998
i=499999
i=500000
2. 判斷執行緒是否停止狀態

Thread.java類中提供了兩種方法：

  1. this.interrupted(): 測試當前執行緒是否已經中斷；
  2. this.isInterrupted(): 測試執行緒是否已經中斷；

那麼這兩個方法有什麼圖區別呢？
我們先來看看this.interrupted()方法的解釋：測試當前執行緒是否已經中斷，當前執行緒是指執行this.interrupted()方法的執行緒。

public class MyThread extends Thread {
    public void run(){
        super.run();
        for(int i=0; i<500000; i++){
            i++;
//            System.out.println("i="+(i+1));
        }
    }
}

public class Run {
    public static void main(String args[]){
        Thread thread = new MyThread();
        thread.start();
        try {
            Thread.sleep(2000);
            thread.interrupt();

            System.out.println("stop 1??" + thread.interrupted());
            System.out.println("stop 2??" + thread.interrupted());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

執行結果：

stop 1??false
stop 2??false

類Run.java中雖然是在thread物件上呼叫以下程式碼：thread.interrupt(), 後面又使用

System.out.println("stop 1??" + thread.interrupted());
System.out.println("stop 2??" + thread.interrupted());

來判斷thread物件所代表的執行緒是否停止，但從控制檯列印的結果來看，執行緒並未停止，這也證明了interrupted()方法的解釋，測試當前執行緒是否已經中斷。這個當前執行緒是main，它從未中斷過，所以列印的結果是兩個false.

如何使main執行緒產生中斷效果呢？

public class Run2 {
    public static void main(String args[]){
        Thread.currentThread().interrupt();
        System.out.println("stop 1??" + Thread.interrupted());
        System.out.println("stop 2??" + Thread.interrupted());

        System.out.println("End");
    }
}

執行效果為：

stop 1??true
stop 2??false
End

方法interrupted()的確判斷出當前執行緒是否是停止狀態。但為什麼第2個布林值是false呢？ 官方幫助文件中對interrupted方法的解釋：
測試當前執行緒是否已經中斷。執行緒的中斷狀態由該方法清除。 換句話說，如果連續兩次呼叫該方法，則第二次呼叫返回false。

下面來看一下inInterrupted()方法。

public class Run3 {
    public static void main(String args[]){
        Thread thread = new MyThread();
        thread.start();
        thread.interrupt();
        System.out.println("stop 1??" + thread.isInterrupted());
        System.out.println("stop 2??" + thread.isInterrupted());
    }
}

執行結果：

stop 1??true
stop 2??true

isInterrupted()併為清除狀態，所以列印了兩個true。

3. 能停止的執行緒--異常法

有了前面學習過的知識點，就可以線上程中用for語句來判斷一下執行緒是否是停止狀態，如果是停止狀態，則後面的程式碼不再執行即可：

public class MyThread extends Thread {
    public void run(){
        super.run();
        for(int i=0; i<500000; i++){
            if(this.interrupted()) {
                System.out.println("執行緒已經終止， for迴圈不再執行");
                break;
            }
            System.out.println("i="+(i+1));
        }
    }
}

public class Run {
    public static void main(String args[]){
        Thread thread = new MyThread();
        thread.start();
        try {
            Thread.sleep(2000);
            thread.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

執行結果：

...
i=202053
i=202054
i=202055
i=202056
執行緒已經終止， for迴圈不再執行

上面的示例雖然停止了執行緒，但如果for語句下面還有語句，還是會繼續執行的。看下面的例子：

public class MyThread extends Thread {
    public void run(){
        super.run();
        for(int i=0; i<500000; i++){
            if(this.interrupted()) {
                System.out.println("執行緒已經終止， for迴圈不再執行");
                break;
            }
            System.out.println("i="+(i+1));
        }

        System.out.println("這是for迴圈外面的語句，也會被執行");
    }
}

使用Run.java執行的結果是：

...
i=180136
i=180137
i=180138
i=180139
執行緒已經終止， for迴圈不再執行
這是for迴圈外面的語句，也會被執行

如何解決語句繼續執行的問題呢？ 看一下更新後的程式碼：

public class MyThread extends Thread {
    public void run(){
        super.run();
        try {
            for(int i=0; i<500000; i++){
                if(this.interrupted()) {
                    System.out.println("執行緒已經終止， for迴圈不再執行");
                        throw new InterruptedException();
                }
                System.out.println("i="+(i+1));
            }

            System.out.println("這是for迴圈外面的語句，也會被執行");
        } catch (InterruptedException e) {
            System.out.println("進入MyThread.java類中的catch了。。。");
            e.printStackTrace();
        }
    }
}

使用Run.java執行的結果如下：

...
i=203798
i=203799
i=203800
執行緒已經終止， for迴圈不再執行
進入MyThread.java類中的catch了。。。
java.lang.InterruptedException
    at thread.MyThread.run(MyThread.java:13)
4. 在沉睡中停止

如果執行緒在sleep()狀態下停止執行緒，會是什麼效果呢？

public class MyThread extends Thread {
    public void run(){
        super.run();

        try {
            System.out.println("執行緒開始。。。");
            Thread.sleep(200000);
            System.out.println("執行緒結束。");
        } catch (InterruptedException e) {
            System.out.println("在沉睡中被停止, 進入catch， 呼叫isInterrupted()方法的結果是：" + this.isInterrupted());
            e.printStackTrace();
        }

    }
}

使用Run.java執行的結果是：

執行緒開始。。。
在沉睡中被停止, 進入catch， 呼叫isInterrupted()方法的結果是：false
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at thread.MyThread.run(MyThread.java:12)

從列印的結果來看， 如果在sleep狀態下停止某一執行緒，會進入catch語句，並且清除停止狀態值，使之變為false。

前一個實驗是先sleep然後再用interrupt()停止，與之相反的操作在學習過程中也要注意：

public class MyThread extends Thread {
    public void run(){
        super.run();
        try {
            System.out.println("執行緒開始。。。");
            for(int i=0; i<10000; i++){
                System.out.println("i=" + i);
            }
            Thread.sleep(200000);
            System.out.println("執行緒結束。");
        } catch (InterruptedException e) {
             System.out.println("先停止，再遇到sleep，進入catch異常");
            e.printStackTrace();
        }

    }
}

public class Run {
    public static void main(String args[]){
        Thread thread = new MyThread();
        thread.start();
        thread.interrupt();
    }
}

執行結果：

i=9998
i=9999
先停止，再遇到sleep，進入catch異常
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at thread.MyThread.run(MyThread.java:15)
5. 能停止的執行緒---暴力停止

使用stop()方法停止執行緒則是非常暴力的。

public class MyThread extends Thread {
    private int i = 0;
    public void run(){
        super.run();
        try {
            while (true){
                System.out.println("i=" + i);
                i++;
                Thread.sleep(200);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

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

執行結果：

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

Process finished with exit code 0
6.方法stop()與java.lang.ThreadDeath異常

呼叫stop()方法時會丟擲java.lang.ThreadDeath異常，但是通常情況下，此異常不需要顯示地捕捉。

public class MyThread extends Thread {
    private int i = 0;
    public void run(){
        super.run();
        try {
            this.stop();
        } catch (ThreadDeath e) {
            System.out.println("進入異常catch");
            e.printStackTrace();
        }
    }
}

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

stop()方法以及作廢，因為如果強制讓執行緒停止有可能使一些清理性的工作得不到完成。另外一個情況就是對鎖定的物件進行了解鎖，導致資料得不到同步的處理，出現數據不一致的問題。

7. 釋放鎖的不良後果

使用stop()釋放鎖將會給資料造成不一致性的結果。如果出現這樣的情況，程式處理的資料就有可能遭到破壞，最終導致程式執行的流程錯誤，一定要特別注意：

public class SynchronizedObject {
    private String name = "a";
    private String password = "aa";

    public synchronized void printString(String name, String password){
        try {
            this.name = name;
            Thread.sleep(100000);
            this.password = password;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

public class MyThread extends Thread {
    private SynchronizedObject synchronizedObject;
    public MyThread(SynchronizedObject synchronizedObject){
        this.synchronizedObject = synchronizedObject;
    }

    public void run(){
        synchronizedObject.printString("b", "bb");
    }
}

public class Run {
    public static void main(String args[]) throws InterruptedException {
        SynchronizedObject synchronizedObject = new SynchronizedObject();
        Thread thread = new MyThread(synchronizedObject);
        thread.start();
        Thread.sleep(500);
        thread.stop();
        System.out.println(synchronizedObject.getName() + "  " + synchronizedObject.getPassword());
    }
}

輸出結果：

b  aa

由於stop()方法以及在JDK中被標明為“過期/作廢”的方法，顯然它在功能上具有缺陷，所以不建議在程式張使用stop()方法。

8. 使用return停止執行緒

將方法interrupt()與return結合使用也能實現停止執行緒的效果：

public class MyThread extends Thread {
    public void run(){
        while (true){
            if(this.isInterrupted()){
                System.out.println("執行緒被停止了！");
                return;
            }
            System.out.println("Time: " + System.currentTimeMillis());
        }
    }
}

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

輸出結果：

...
Time: 1467072288503
Time: 1467072288503
Time: 1467072288503
執行緒被停止了！

不過還是建議使用“拋異常”的方法來實現執行緒的停止，因為在catch塊中還可以將異常向上拋，使執行緒停止事件得以傳播。

相關推薦

如何正確地停止一個執行緒？

停止一個執行緒意味著在任務處理完任務之前停掉正在做的操作，也就是放棄當前的操作。停止一個執行緒可以用Thread.stop()方法，但最好不要用它。雖然它確實可以停止一個正在執行的執行緒，但是這個方法是不安全的，而且是已被廢棄的方法。 在java中有以下3種方法可以終止正在執行的執行緒： 使用退出標誌，使執

如何停止一個執行緒

停止一個執行緒意味著在任務處理完任務之前停掉正在做的操作，也就是放棄當前的操作。停止一個執行緒可以用Thread.stop()方法，但最好不要用它。雖然它確實可以停止一個正在執行的執行緒，但是這個方法是不安全的，而且是已被廢棄的方法。 在java中有以下3種方法可以終止正

Java停止一個執行緒的幾種方法

Java中停止一個執行緒有三種方法，分別是stop,interrupt和設定標誌位，我們依次來看一下這三種方法。 首先不推薦使用stop方法，原因有兩點： 1、原則上只要一呼叫thread.stop()方法，執行緒就會立即停止，並丟擲ThreadDeath error，查看

百度Android面試題之如何停止一個執行緒

前段時間去面試了百度android職位，雖然沒有通過，但是發現了很多自己的不足，回來痛定思痛，決定將所有的面試題整理到CSDN上，查漏補缺。問：如何停止一個執行緒？由於平時不怎麼寫多執行緒，所以直接說了個interrupt()顯然是不對的。那麼接下來我們探討一下java中如何

如何優雅的停止一個執行緒？

![](https://img2020.cnblogs.com/other/2024393/202010/2024393-20201012190414882-1780446894.png) 在之前的文章中 [i-code.online -《併發程式設計-執行緒基礎》](https://i-code.onli

我們該如何正確的中斷一個執行緒的執行？？

## 寫在前面 > 當我們在呼叫Java物件的wait()方法或者執行緒的sleep()方法時，需要捕獲並處理InterruptedException異常。如果我們對InterruptedException異常處理不當，則會發生我們意想不到的後果！今天，我們就以一個案例的形式，來為大家詳細介紹下為何中

一個執行緒OOM後其餘執行緒是否停止

OOM：Out Of Memory。        在多執行緒環境下，每個執行緒擁有一個棧和一個程式計數器。棧和程式計數器用來儲存執行緒的執行歷史和執行緒的執行狀態，是執行緒私有的資源，也就是說，堆是執行緒共享。其他的資源（比如堆、地址空間、全域性變數）是由同一個程序內的多

golang的一個執行緒排程被停止的問題處理

最近發現, golang寫的遊戲伺服器, 在非除錯狀態下, 一切正常, 但是在掛接gdb除錯時, 無法收到網路訊息. 打了很多日誌, 發現, 只要有goroutine的地方, 都沒有切換進入. 回想了下, goroutine的排程規則: 1.4之前, 在碰到syscall時, goroutine會被

網路程式設計基礎【day10】：我是一個執行緒（四）

本節內容 1、第一回 初生牛犢 2、第二回 漸入佳境 3、第三回 虎口脫險 4、第四回 江湖再見 第一回 初生牛犢 我是一個執行緒，我一出生就被編了個號：0x3704，然後被領到一個昏暗的屋子裡，在這裡我發現了很多和我一模一樣的同伴。 我身邊的同伴0x6900 待的時間比較長，他帶著滄桑的口氣對

如何實現一個執行緒排程框架

一、前言 執行緒是程式執行流的最小單元，很基礎，也很重要。為了提高流暢性，耗時任務放後臺執行緒執行，這是APP開發的常識了。隨著APP複雜度的提升，越來越多工需要開執行緒執行，同時，遇到如下挑戰： 任務場景多樣化，常規的API無法滿足； 隨著元件化，模組化等演進，可能使得執行緒管理不統一(比如多

Thread和Runnable的區別和聯絡、多次start一個執行緒會怎麼樣

一、Java有兩種方式實現多執行緒，第一個是繼承Thread類，第二個是實現Runnable介面。他們之間的聯絡： 　　  1、Thread類實現了Runable介面。 　　2、都需要重寫裡面Run方法。 二、實現Runnable介面相對於繼承Thread類來說，有如下顯著的好處：

一個執行緒控制另一個執行緒的暫停或啟動

MainTest類中可以控制執行緒的暫停或繼續執行。 public class MainTest { /** * 這個執行緒操作另一個執行緒的暫停或開始 * @param args */ public static void main(String[] args) {

實現一個執行緒池

1.定義執行緒池  //業務執行緒池 private static final ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()

JAVA裡面如何讓一個執行緒死亡或結束

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

【小家java】Java中的執行緒池，你真的用對了嗎？（教你用正確的姿勢使用執行緒池）

相關閱讀 【小家java】java5新特性（簡述十大新特性） 重要一躍 【小家java】java6新特性（簡述十大新特性） 雞肋升級 【小家java】java7新特性（簡述八大新特性） 不溫不火 【小家java】java8新特性（簡述十大新特性） 飽受讚譽 【小家java】java9

C++設計一個執行緒安全的懶漢單例模式

#incldue<iostream> #include<mutex> using namespace std; class CSingleton { public: static CSingleton* GetCSingleton() { if (_p ==

寫兩個執行緒，一個執行緒列印 1~52，另一個執行緒列印A~Z， 列印順序是12A34B...5152Z

這個題目就是要用wait()和notify()方法來控制兩個執行緒的執行 看如下程式碼： 當標誌位flag為1 時，列印數字；否則列印字母 count即為列印的數字 class Print { private int flag = 1;

JAVA定義一個執行緒池,迴圈遍歷list

文章目錄 前言 思路 下面是我自己專案中的呼叫程式碼，供你參考（ProcessNumTask就是那個實現Callable的任務）： Callable與Future的介紹 Callable的介面定義如下:

用面向物件重寫thread 實現多次呼叫一個執行緒

思路： 　　利用thread類中，run方法在子執行緒中呼叫，其他方法在主執行緒呼叫，所以將生產者寫入主執行緒，將消費者寫入run函式中在子執行緒中執行，完成生產者消費者模型 注意： 　　1.　　要在 init 函式中例項化一個Queue佇列作為生產者消費者中介 　　2.　　要在 init 函式中把d

Java:寫2個執行緒，其中一個執行緒列印1-52，另一個執行緒列印A-Z，列印順序應該是12A34B56C...5152Z。

寫2個執行緒，其中一個執行緒列印1-52，另一個執行緒列印A-Z，列印順序應該是12A34B56C...5152Z   多執行緒程式設計：使用Runnable介面例項建立執行緒。使用執行緒等待方法wait()； package com.java瘋狂講義; public