jva 線程的生命週期和狀態控制

轉載出自於：http://blog.csdn.net/lonelyroamer/article/details/7949969

一、線程的生命週期

線程狀態轉換圖：

1、新建狀態

用new關鍵字和Thread類或其子類建立一個線程對象後，該線程對象就處於新生狀態。處於新生狀態的線程有自己的內存空間，通過調用start方法進入就緒狀態（runnable）。

注意：不能對已經啓動的線程再次調用start()方法，否則會出現Java.lang.IllegalThreadStateException異常。

2、就緒狀態

處於就緒狀態的線程已經具備了運行條件，但還沒有分配到CPU，處於線程就緒隊列（儘管是採用隊列形式，事實上，把它稱爲可運行池而不是可運行隊列。因爲cpu的調度不一定是按照先進先出的順序來調度的），等待系統爲其分配CPU。等待狀態並不是執行狀態，當系統選定一個等待執行的Thread對象後，它就會從等待執行狀態進入執行狀態，系統挑選的動作稱之爲“cpu調度”。一旦獲得CPU，線程就進入運行狀態並自動調用自己的run方法。

提示：如果希望子線程調用start()方法後立即執行，可以使用Thread.sleep()方式使主線程睡眠一夥兒，轉去執行子線程。

3、運行狀態

處於運行狀態的線程最爲複雜，它可以變爲阻塞狀態、就緒狀態和死亡狀態。

處於就緒狀態的線程，如果獲得了cpu的調度，就會從就緒狀態變爲運行狀態，執行run()方法中的任務。如果該線程失去了cpu資源，就會又從運行狀態變爲就緒狀態。重新等待系統分配資源。也可以對在運行狀態的線程調用yield()方法，它就會讓出cpu資源，再次變爲就緒狀態。

當發生如下情況是，線程會從運行狀態變爲阻塞狀態：

①、線程調用sleep方法主動放棄所佔用的系統資源

②、線程調用一個阻塞式IO方法，在該方法返回之前，該線程被阻塞

③、線程試圖獲得一個同步監視器，但更改同步監視器正被其他線程所持有

④、線程在等待某個通知（notify）

⑤、程序調用了線程的suspend方法將線程掛起。不過該方法容易導致死鎖，所以程序應該儘量避免使用該方法。

當線程的run()方法執行完，或者被強制性地終止，例如出現異常，或者調用了stop()、desyory()方法等等，就會從運行狀態轉變爲死亡狀態。

4、阻塞狀態

處於運行狀態的線程在某些情況下，如執行了sleep（睡眠）方法，或等待I/O設備等資源，將讓出CPU並暫時停止自己的運行，進入阻塞狀態。 

在阻塞狀態的線程不能進入就緒隊列。只有當引起阻塞的原因消除時，如睡眠時間已到，或等待的I/O設備空閒下來，線程便轉入就緒狀態，重新到就緒隊列中排隊等待，被系統選中後從原來停止的位置開始繼續運行。有三種方法可以暫停Threads執行：

5、死亡狀態

當線程的run()方法執行完，或者被強制性地終止，就認爲它死去。這個線程對象也許是活的，但是，它已經不是一個單獨執行的線程。線程一旦死亡，就不能復生。 如果在一個死去的線程上調用start()方法，會拋出java.lang.IllegalThreadStateException異常。

二、線程狀態的控制

Java提供了一些便捷的方法用於會線程狀態的控制。 .

void	destroy()           已過時。 該方法最初用於破壞該線程，但不作任何清除。它所保持的任何監視器都會保持鎖定狀態。不過，該方法決不會被實現。即使要實現，它也極有可能以suspend() 方式被死鎖。如果目標線程被破壞時保持一個保護關鍵系統資源的鎖，則任何線程在任何時候都無法再次訪問該資源。如果另一個線程曾試圖鎖定該資源，則會出現死鎖。這類死鎖通常會證明它們自己是“凍結”的進程。有關更多信息，請參閱爲何不贊成使用 Thread.stop、Thread.suspend 和 Thread.resume？。
void	interrupt()           中斷線程。
void	join()           等待該線程終止。
void	join(long millis)           等待該線程終止的時間最長爲 millis 毫秒。
void	join(long millis, int nanos)           等待該線程終止的時間最長爲 millis 毫秒 + nanos 納秒。
void	resume()           已過時。 該方法只與 suspend() 一起使用，但 suspend() 已經遭到反對，因爲它具有死鎖傾向。有關更多信息，請參閱爲何不贊成使用 Thread.stop、Thread.suspend 和 Thread.resume？。
void	setDaemon(boolean on)           將該線程標記爲守護線程或用戶線程。
void	setPriority(int newPriority)           更改線程的優先級。
static void	sleep(long millis)           在指定的毫秒數內讓當前正在執行的線程休眠（暫停執行），此操作受到系統計時器和調度程序精度和準確性的影響。
static void	sleep(long millis, int nanos)           在指定的毫秒數加指定的納秒數內讓當前正在執行的線程休眠（暫停執行），此操作受到系統計時器和調度程序精度和準確性的影響。
void	start()           使該線程開始執行；Java 虛擬機調用該線程的 run 方法。
void	stop()           已過時。 該方法具有固有的不安全性。用 Thread.stop 來終止線程將釋放它已經鎖定的所有監視器（作爲沿堆棧向上傳播的未檢查ThreadDeath 異常的一個自然後果）。如果以前受這些監視器保護的任何對象都處於一種不一致的狀態，則損壞的對象將對其他線程可見，這有可能導致任意的行爲。stop 的許多使用都應由只修改某些變量以指示目標線程應該停止運行的代碼來取代。目標線程應定期檢查該變量，並且如果該變量指示它要停止運行，則從其運行方法依次返回。如果目標線程等待很長時間（例如基於一個條件變量），則應使用interrupt 方法來中斷該等待。有關更多信息，請參閱爲何不贊成使用 Thread.stop、Thread.suspend 和 Thread.resume？。
void	stop(Throwable obj)           已過時。 該方法具有固有的不安全性。有關詳細信息，請參閱 stop()。該方法的附加危險是它可用於生成目標線程未準備處理的異常（包括若沒有該方法該線程不太可能拋出的已檢查的異常）。有關更多信息，請參閱爲何不贊成使用 Thread.stop、Thread.suspend 和 Thread.resume？。
void	suspend()           已過時。 該方法已經遭到反對，因爲它具有固有的死鎖傾向。如果目標線程掛起時在保護關鍵系統資源的監視器上保持有鎖，則在目標線程重新開始以前任何線程都不能訪問該資源。如果重新開始目標線程的線程想在調用resume 之前鎖定該監視器，則會發生死鎖。這類死鎖通常會證明自己是“凍結”的進程。有關更多信息，請參閱爲何不贊成使用 Thread.stop、Thread.suspend 和 Thread.resume？。
static void	yield()           暫停當前正在執行的線程對象，並執行其他線程。

 

可以看到很多方法，已經標註爲過時的，我們應該儘可能的避免使用它們，而應該重點關注start()、interrupt()、join()、sleep()、yield()等直接控制方法，和setDaemon()、setPriority()等間接控制方法。

1、線程睡眠——sleep

如果我們需要讓當前正在執行的線程暫停一段時間，並進入阻塞狀態，則可以通過調用Thread的sleep方法，從上面可以看到sleep方法有兩種重載的形式，但是使用方法一樣。

比如，我們想要使主線程每休眠100毫秒，然後再打印出數字：

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        for(int i=0;i<100;i++){
            System.out.println("main"+i);
            Thread.sleep(100);
        }
    }
}

可以明顯看到打印的數字在時間上有些許的間隔。

注意如下幾點問題

①、sleep是靜態方法，最好不要用Thread的實例對象調用它，因爲它睡眠的始終是當前正在運行的線程，而不是調用它的線程對象，它只對正在運行狀態的線程對象有效。看下面的例子：

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        System.out.println(Thread.currentThread().getName());
        MyThread myThread=new MyThread();
        myThread.start();
        myThread.sleep(1000);//這裏sleep的就是main線程，而非myThread線程
        Thread.sleep(10);
        for(int i=0;i<100;i++){
            System.out.println("main"+i);
        }
    }
}

②、Java線程調度是Java多線程的核心，只有良好的調度，才能充分發揮系統的性能，提高程序的執行效率。但是不管程序員怎麼編寫調度，只能最大限度的影響線程執行的次序，而不能做到精準控制。因爲使用sleep方法之後，線程是進入阻塞狀態的，只有當睡眠的時間結束，纔會重新進入到就緒狀態，而就緒狀態進入到運行狀態，是由系統控制的，我們不可能精準的去幹涉它，所以如果調用Thread.sleep(1000)使得線程睡眠1秒，可能結果會大於1秒。

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

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(this.getName()+"線程" + i + "次執行！");
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

看某一次的運行結果：

Thread-0線程0次執行！
Thread-1線程0次執行！
Thread-1線程1次執行！
Thread-0線程1次執行！
Thread-0線程2次執行！
Thread-1線程2次執行！

可以看到，線程0首先執行，然後線程1執行一次，又了執行一次。可以看到它並不是按照sleep的順序執行的。

2、線程讓步——yield

yield()方法和sleep()方法有點相似，它也是Thread類提供的一個靜態的方法，它也可以讓當前正在執行的線程暫停，讓出cpu資源給其他的線程。但是和sleep()方法不同的是，它不會進入到阻塞狀態，而是進入到就緒狀態。yield()方法只是讓當前線程暫停一下，重新進入就緒的線程池中，讓系統的線程調度器重新調度器重新調度一次，完全可能出現這樣的情況：當某個線程調用yield()方法之後，線程調度器又將其調度出來重新進入到運行狀態執行。

實際上，當某個線程調用了yield()方法暫停之後，優先級與當前線程相同，或者優先級比當前線程更高的就緒狀態的線程更有可能獲得執行的機會，當然，只是有可能，因爲我們不可能精確的干涉cpu調度線程。

yield的用法：

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        new MyThread("低級", 1).start();
        new MyThread("中級", 5).start();
        new MyThread("高級", 10).start();
    }
}

class MyThread extends Thread {
    public MyThread(String name, int pro) {
        super(name);// 設置線程的名稱
        this.setPriority(pro);// 設置優先級
    }

    @Override
    public void run() {
        for (int i = 0; i < 30; i++) {
            System.out.println(this.getName() + "線程第" + i + "次執行！");
            if (i % 5 == 0)
                Thread.yield();
        }
    }
}

關於sleep()方法和yield()方的區別如下：

①、sleep方法暫停當前線程後，會進入阻塞狀態，只有當睡眠時間到了，纔會轉入就緒狀態。而yield方法調用後 ，是直接進入就緒狀態，所以有可能剛進入就緒狀態，又被調度到運行狀態。

②、sleep方法聲明拋出了InterruptedException，所以調用sleep方法的時候要捕獲該異常，或者顯示聲明拋出該異常。而yield方法則沒有聲明拋出任務異常。

③、sleep方法比yield方法有更好的可移植性，通常不要依靠yield方法來控制併發線程的執行。

3、線程合併——join

線程的合併的含義就是將幾個並行線程的線程合併爲一個單線程執行，應用場景是當一個線程必須等待另一個線程執行完畢才能執行時，Thread類提供了join方法來完成這個功能，注意，它不是靜態方法。
從上面的方法的列表可以看到，它有3個重載的方法：
void join()    
    當前線程等該加入該線程後面，等待該線程終止。    
void join(long millis)    
    當前線程等待該線程終止的時間最長爲 millis 毫秒。 如果在millis時間內，該線程沒有執行完，那麼當前線程進入就緒狀態，重新等待cpu調度   
void join(long millis,int nanos)    
    等待該線程終止的時間最長爲 millis 毫秒 + nanos 納秒。如果在millis時間內，該線程沒有執行完，那麼當前線程進入就緒狀態，重新等待cpu調度  

例子：

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        MyThread thread=new MyThread();
        thread.start();
        thread.join(1);//將主線程加入到子線程後面，不過如果子線程在1毫秒時間內沒執行完，則主線程便不再等待它執行完，進入就緒狀態，等待cpu調度
        for(int i=0;i<30;i++){
            System.out.println(Thread.currentThread().getName() + "線程第" + i + "次執行！");
        }
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(this.getName() + "線程第" + i + "次執行！");
        }
    }
}

在這個例子中，在主線程中調用thread.join(); 就是將主線程加入到thread子線程後面等待執行。不過有時間限制，爲1毫秒。

4、線程的優先級

每個線程執行時都有一個優先級的屬性，優先級高的線程可以獲得較多的執行機會，而優先級低的線程則獲得較少的執行機會。與線程休眠類似，線程的優先級仍然無法保障線程的執行次序。只不過，優先級高的線程獲取CPU資源的概率較大，優先級低的也並非沒機會執行。

每個線程默認的優先級都與創建它的父線程具有相同的優先級，在默認情況下，main線程具有普通優先級。

Thread類提供了setPriority(int newPriority)和getPriority()方法來設置和返回一個指定線程的優先級，其中setPriority方法的參數是一個整數，範圍是1~·0之間，也可以使用Thread類提供的三個靜態常量：

MAX_PRIORITY   =10

MIN_PRIORITY   =1

NORM_PRIORITY   =5

例子：

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        new MyThread("高級", 10).start();
        new MyThread("低級", 1).start();
    }
}

class MyThread extends Thread {
    public MyThread(String name,int pro) {
        super(name);//設置線程的名稱
        setPriority(pro);//設置線程的優先級
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.getName() + "線程第" + i + "次執行！");
        }
    }
}

從結果可以看到 ，一般情況下，高級線程更顯執行完畢。

注意一點：雖然Java提供了10個優先級別，但這些優先級別需要操作系統的支持。不同的操作系統的優先級並不相同，而且也不能很好的和Java的10個優先級別對應。所以我們應該使用MAX_PRIORITY、MIN_PRIORITY和NORM_PRIORITY三個靜態常量來設定優先級，這樣才能保證程序最好的可移植性。

5、守護線程

守護線程與普通線程寫法上基本麼啥區別，調用線程對象的方法setDaemon(true)，則可以將其設置爲守護線程。

 

守護線程使用的情況較少，但並非無用，舉例來說，JVM的垃圾回收、內存管理等線程都是守護線程。還有就是在做數據庫應用時候，使用的數據庫連接池，連接池本身也包含着很多後臺線程，監控連接個數、超時時間、狀態等等。

 

setDaemon方法的詳細說明：
public final void setDaemon(boolean on)將該線程標記爲守護線程或用戶線程。當正在運行的線程都是守護線程時，Java 虛擬機退出。    
該方法必須在啓動線程前調用。 該方法首先調用該線程的 checkAccess 方法，且不帶任何參數。這可能拋出 SecurityException（在當前線程中）。   
  參數： 
    on - 如果爲 true，則將該線程標記爲守護線程。    
  拋出：    
    IllegalThreadStateException - 如果該線程處於活動狀態。    
    SecurityException - 如果當前線程無法修改該線程。

/**
* Java線程：線程的調度-守護線程
*/
public class Test {
        public static void main(String[] args) {
                Thread t1 = new MyCommon();
                Thread t2 = new Thread(new MyDaemon());
                t2.setDaemon(true);        //設置爲守護線程

                t2.start();
                t1.start();
        }
}

class MyCommon extends Thread {
        public void run() {
                for (int i = 0; i < 5; i++) {
                        System.out.println("線程1第" + i + "次執行！");
                        try {
                                Thread.sleep(7);
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                }
        }
}

class MyDaemon implements Runnable {
        public void run() {
                for (long i = 0; i < 9999999L; i++) {
                        System.out.println("後臺線程第" + i + "次執行！");
                        try {
                                Thread.sleep(7);
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                }
        }
}

執行結果：

後臺線程第0次執行！
線程1第0次執行！
線程1第1次執行！
後臺線程第1次執行！
後臺線程第2次執行！
線程1第2次執行！
線程1第3次執行！
後臺線程第3次執行！
線程1第4次執行！
後臺線程第4次執行！
後臺線程第5次執行！
後臺線程第6次執行！
後臺線程第7次執行！

從上面的執行結果可以看出：前臺線程是保證執行完畢的，後臺線程還沒有執行完畢就退出了。

 

實際上：JRE判斷程序是否執行結束的標準是所有的前臺執線程行完畢了，而不管後臺線程的狀態，因此，在使用後臺縣城時候一定要注意這個問題。

守護線程的用途：

守護線程通常用於執行一些後臺作業，例如在你的應用程序運行時播放背景音樂，在文字編輯器裏做自動語法檢查、自動保存等功能。Java的垃圾回收也是一個守護線程。守護線

的好處就是你不需要關心它的結束問題。例如你在你的應用程序運行的時候希望播放背景音樂，如果將這個播放背景音樂的線程設定爲非守護線程，那麼在用戶請求退出的時候，

不僅要退出主線程，還要通知播放背景音樂的線程退出；如果設定爲守護線程則不需要了。

6、如何結束一個線程

Thread.stop()、Thread.suspend、Thread.resume、Runtime.runFinalizersOnExit這些終止線程運行的方法已經被廢棄了，使用它們是極端不安全的！想要安全有效的結束一個線程，可以使用下面的方法。

1、正常執行完run方法，然後結束掉

2、控制循環條件和判斷條件的標識符來結束掉線程

比如說run方法這樣寫：

class MyThread extends Thread {
    int i=0;
    @Override
    public void run() {
        while (true) {
            if(i==10)
                break;
            i++;
            System.out.println(i);

        }
    }
}

或者

class MyThread extends Thread {
    int i=0;
    boolean next=true;
    @Override
    public void run() {
        while (next) {
            if(i==10)
                next=false;
            i++;
            System.out.println(i);
        }
    }
}

或者

class MyThread extends Thread {
    int i=0;
    @Override
    public void run() {
        while (true) {
            if(i==10)
                return;
            i++;
            System.out.println(i);
        }
    }
}

只要保證在一定的情況下，run方法能夠執行完畢即可。而不是while(true)的無線循環。

3、使用interrupt結束一個線程。

誠然，使用第2中方法的標識符來結束一個線程，是一個不錯的方法，但是如果，該線程是處於sleep、wait、join的狀態的時候，while循環就不會執行，那麼我們的標識符就無用武之地了，當然也不能再通過它來結束處於這3種狀態的線程了。

可以使用interrupt這個巧妙的方式結束掉這個線程。

我們看看sleep、wait、join方法的聲明：

public final void wait() throws InterruptedException

public static native void sleep(long millis) throws InterruptedException

public final void join() throws InterruptedException

可以看到，這三者有一個共同點，都拋出了一個InterruptedException的異常。

在什麼時候會產生這樣一個異常呢？

每個Thread都有一箇中斷狀狀態，默認爲false。可以通過Thread對象的isInterrupted()方法來判斷該線程的中斷狀態。可以通過Thread對象的interrupt()方法將中斷狀態設置爲true。

當一個線程處於sleep、wait、join這三種狀態之一的時候，如果此時他的中斷狀態爲true，那麼它就會拋出一個InterruptedException的異常，並將中斷狀態重新設置爲false。

看下面的簡單的例子：

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

class MyThread extends Thread {
    int i=1;
    @Override
    public void run() {
        while (true) {
            System.out.println(i);
            System.out.println(this.isInterrupted());
            try {
                System.out.println("我馬上去sleep了");
                Thread.sleep(2000);
                this.interrupt();
            } catch (InterruptedException e) {
                System.out.println("異常捕獲了"+this.isInterrupted());
                return;
            }
            i++;
        }
    }
}

測試結果：

1
false
我馬上去sleep了
2
true
我馬上去sleep了
異常捕獲了false

可以看到，首先執行第一次while循環，在第一次循環中，睡眠2秒，然後將中斷狀態設置爲true。當進入到第二次循環的時候，中斷狀態就是第一次設置的true，當它再次進入sleep的時候，馬上就拋出了InterruptedException異常，然後被我們捕獲了。然後中斷狀態又被重新自動設置爲false了（從最後一條輸出可以看出來）。

所以，我們可以使用interrupt方法結束一個線程。具體使用如下：

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

class MyThread extends Thread {
    int i=0;
    @Override
    public void run() {
        while (true) {
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("中斷異常被捕獲了");
                return;
            }
            i++;
        }
    }
}

多測試幾次，會發現一般有兩種執行結果：

0
1
2
中斷異常被捕獲了

或者

0
1
2
3
中斷異常被捕獲了

這兩種結果恰恰說明了  只要一個線程的中斷狀態一旦爲true，只要它進入sleep等狀態，或者處於sleep狀態，立馬回拋出InterruptedException異常。

第一種情況，是當主線程從3秒睡眠狀態醒來之後，調用了子線程的interrupt方法，此時子線程正處於sleep狀態，立馬拋出InterruptedException異常。

第一種情況，是當主線程從3秒睡眠狀態醒來之後，調用了子線程的interrupt方法，此時子線程還沒有處於sleep狀態。然後再第3次while循環的時候，在此進入sleep狀態，立馬拋出InterruptedException異常。