Java多線程之線程狀態轉換、控制線程和線程同步

Java多線程之線程狀態轉換、控制線程和線程同步

• 前言：我是一名android，實際上我是大連理工大學的一名大四小白！Java多線程系列博客是我自己從衆多博客以及一些書總結出來的文章。內容均爲總結性內容，用於自己複習研究以及廣大同仁們交流！如果大家想要看這篇博客，請務必先看看它系列博客的前一篇：Java多線程之多線程概述和三種概述方式。

（一）.線程狀態轉換

1. 新建狀態（New）：新創建了一個線程對象。Java虛擬機爲其分配內存，並初始化成員變量。
2. 就緒狀態（Runnable）：線程對象調用了start()方法之後，線程處於就緒狀態，Java虛擬機會爲其創建方法調用棧和程序計數器。該狀態的線程位於可運行線程池中，變得可運行，等待獲取CPU的使用權。
3. 運行狀態（Running）：就緒狀態的線程獲取了CPU，執行程序代碼。
4. 阻塞狀態（Blocked）：阻塞狀態是線程因爲某種原因放棄了CPU使用權，暫時停止運行。直到線程進入就緒狀態，纔有機會轉到運行態。
   阻塞的情況分三種：
   一）、等待阻塞：運行的線程執行wait()方法，JVM會把該線程放入等待池中。(wait會釋放持有的鎖)
   二）、同步阻塞：運行的線程在獲取對象的同步鎖時，若該同步鎖被別的線程佔用，則JVM會把該線程放入鎖池中。
   （三）、其他阻塞：運行的線程執行sleep()或join()方法，或者發出了I/O請求時，JVM會把該線程置爲阻塞狀態。當sleep()狀態超時、join()等待線程終止或者超時、或者I/O處理完畢時，線程重新轉入就緒狀態。（注意,sleep是不會釋放持有的鎖）

５.死亡狀態（Dead）：線程執行完了或者因異常退出了run()方法，該線程結束生命週期。當線程結束時，其他線程不會受到任何影響，並不會隨之結束，一旦子線程啓動後，它就擁有和主線程相同的地位。

（二）.控制線程

（一）.join線程：Thread提供了讓一個線程等待另一個線程完成的方法–join()方法。在當前線程中調用另一個線程的join()方法，則當前線程轉入阻塞狀態，直到另一個進程運行結束，當前線程再由阻塞轉爲就緒狀態。

package com.multithread.join;  
class Thread1 extends Thread{  
    private String name;  
    public Thread1(String name) {  
        super(name);  
       this.name=name;  
    }  
    public void run() {  
        System.out.println(Thread.currentThread().getName() + " 線程運行開始!");  
        for (int i = 0; i < 5; i++) {  
            System.out.println("子線程"+name + "運行 : " + i);  
            try {  
                sleep((int) Math.random() * 10);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
        System.out.println(Thread.currentThread().getName() + " 線程運行結束!");  
    }  
}  

public class Main {  

    public static void main(String[] args) {  
        System.out.println(Thread.currentThread().getName()+"主線程運行開始!");  
        Thread1 mTh1=new Thread1("A");  
        Thread1 mTh2=new Thread1("B");  
        mTh1.start();  
        mTh2.start();  
        System.out.println(Thread.currentThread().getName()+ "主線程運行結束!");  

    }  

}  

輸出結果：
main主線程運行開始!
main主線程運行結束!
B 線程運行開始!
子線程B運行 : 0
A 線程運行開始!
子線程A運行 : 0
子線程B運行 : 1
子線程A運行 : 1
子線程A運行 : 2
子線程A運行 : 3
子線程A運行 : 4
A 線程運行結束!
子線程B運行 : 2
子線程B運行 : 3
子線程B運行 : 4
B 線程運行結束!
發現主線程比子線程早結束

加join

public class Main {  

    public static void main(String[] args) {  
        System.out.println(Thread.currentThread().getName()+"主線程運行開始!");  
        Thread1 mTh1=new Thread1("A");  
        Thread1 mTh2=new Thread1("B");  
        mTh1.start();  
        mTh2.start();  
        try {  
            mTh1.join();  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        try {  
            mTh2.join();  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        System.out.println(Thread.currentThread().getName()+ "主線程運行結束!");  

    }  

}  

運行結果：
main主線程運行開始!
A 線程運行開始!
子線程A運行 : 0
B 線程運行開始!
子線程B運行 : 0
子線程A運行 : 1
子線程B運行 : 1
子線程A運行 : 2
子線程B運行 : 2
子線程A運行 : 3
子線程B運行 : 3
子線程A運行 : 4
子線程B運行 : 4
A 線程運行結束!
主線程一定會等子線程都結束了才結束

（二）.後臺線程：有一種線程它是在後臺運行的，任務是爲其他的線程提供服務,這種線程被稱爲“後臺線程”。JVM的垃圾回收線程就是典型的後臺線程。
　　後臺線程有一個典型特徵，前臺線程都死亡了，後臺線程會自動死亡。調用Thread對象的setDaemon(true)方法可以將指定線程設定爲後臺線程。

（三）.線程睡眠 Sleep：Thread.sleep(long millis)方法，使線程轉到阻塞狀態。millis參數設定睡眠的時間，以毫秒爲單位。當睡眠結束後，就轉爲就緒（Runnable）狀態。sleep()平臺移植性好。

(四).線程讓步 yield：暫停當前正在執行的線程對象，並執行其他線程。 Thread.yield()方法作用是：暫停當前正在執行的線程對象，並執行其他線程。 yield()應該做的是讓當前運行線程回到可運行狀態，以允許具有相同優先級的其他線程獲得運行機會。因此，使用yield()的目的是讓相同優先級的線程之間能適當的輪轉執行。但是，實際中無法保證yield()達到讓步目的，因爲讓步的線程還有可能被線程調度程序再次選中。

package com.multithread.yield;  
class ThreadYield extends Thread{  
    public ThreadYield(String name) {  
        super(name);  
    }  

    @Override  
    public void run() {  
        for (int i = 1; i <= 50; i++) {  
            System.out.println("" + this.getName() + "-----" + i);  
            // 當i爲30時，該線程就會把CPU時間讓掉，讓其他或者自己的線程執行（也就是誰先搶到誰執行）  
            if (i ==30) {  
                this.yield();  
            }  
        }  

}  
}  

public class Main {  

    public static void main(String[] args) {  

        ThreadYield yt1 = new ThreadYield("張三");  
        ThreadYield yt2 = new ThreadYield("李四");  
        yt1.start();  
        yt2.start();  
    }  

} 

第一種情況：李四（線程）當執行到30時會CPU時間讓掉，這時張三（線程）搶到CPU時間並執行。
第二種情況：李四（線程）當執行到30時會CPU時間讓掉，這時李四（線程）搶到CPU時間並執行。

【sleep()和yield()的區別】sleep()使當前線程處於阻塞狀態，所以執行sleep()的線程在指定時間內肯定不會被執行；yield()方法只是使當前程序重新回到可執行狀態，所以執行yield()的線程有可能在進入到可執行狀態後馬上又被執行。sleep()方法允許較低優先權的線程獲得運行機會，但yield()方法只會讓相同或較高優先權的線程獲得運行機會。

（五）.中斷線程：interrupt();

（六）.wait():Obj.wait()，與Obj.notify()必須要與synchronized(Obj)一起使用，也就是wait,與notify是針對已經獲取了Obj鎖進行操作，從語法角度來說就是Obj.wait(),Obj.notify必須在synchronized(Obj){…}語句塊內。從功能上來說wait就是說線程在獲取對象鎖後，主動釋放對象鎖，同時本線程休眠。直到有其它線程調用對象的notify()喚醒該線程，才能繼續獲取對象鎖，並繼續執行。相應的notify()就是對對象鎖的喚醒操作。但有一點需要注意的是notify()調用後，並不是馬上就釋放對象鎖的，而是在相應的synchronized(){}語句塊執行結束，自動釋放鎖後，JVM會在wait()對象鎖的線程中隨機選取一線程，賦予其對象鎖，喚醒線程，繼續執行。這樣就提供了在線程間同步、喚醒的操作。Thread.sleep()與Object.wait()二者都可以暫停當前線程，釋放CPU控制權，主要的區別在於Object.wait()在釋放CPU同時，釋放了對象鎖的控制。
　　 【例子】單單在概念上理解清楚了還不夠，需要在實際的例子中進行測試才能更好的理解。對Object.wait()，Object.notify()的應用最經典的例子，應該是三線程打印ABC的問題了吧，這是一道比較經典的面試題，題目要求如下：
　　 建立三個線程，A線程打印10次A，B線程打印10次B,C線程打印10次C，要求線程同時運行，交替打印10次ABC。這個問題用Object的wait()，notify()就可以很方便的解決。代碼如下：

package com.multithread.wait;
public class MyThreadPrinter2 implements Runnable {   

    private String name;   
    private Object prev;   
    private Object self;   

    private MyThreadPrinter2(String name, Object prev, Object self) {   
        this.name = name;   
        this.prev = prev;   
        this.self = self;   
    }   

    @Override  
    public void run() {   
        int count = 10;   
        while (count > 0) {   
            synchronized (prev) {   
                synchronized (self) {   
                    System.out.print(name);   
                    count--;  

                    self.notify();   
                }   
                try {   
                    prev.wait();   
                } catch (InterruptedException e) {   
                    e.printStackTrace();   
                }   
            }   

        }   
    }   

    public static void main(String[] args) throws Exception {   
        Object a = new Object();   
        Object b = new Object();   
        Object c = new Object();   
        MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);   
        MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);   
        MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);   


        new Thread(pa).start();
        Thread.sleep(100);  //確保按順序A、B、C執行
        new Thread(pb).start();
        Thread.sleep(100);  
        new Thread(pc).start();   
        Thread.sleep(100);  
        }   
}  

輸出結果：
ABCABCABCABCABCABCABCABCABCABC

【解釋】先來解釋一下其整體思路，從大的方向上來講，該問題爲三線程間的同步喚醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循環執行三個線程。爲了控制線程執行的順序，那麼就必須要確定喚醒、等待的順序，所以每一個線程必須同時持有兩個對象鎖，才能繼續執行。一個對象鎖是prev，就是前一個線程所持有的對象鎖。還有一個就是自身對象鎖。主要的思想就是，爲了控制執行的順序，必須要先持有prev鎖，也就前一個線程要釋放自身對象鎖，再去申請自身對象鎖，兩者兼備時打印，之後首先調用self.notify()釋放自身對象鎖，喚醒下一個等待線程，再調用prev.wait()釋放prev對象鎖，終止當前線程，等待循環結束後再次被喚醒。運行上述代碼，可以發現三個線程循環打印ABC，共10次。程序運行的主要過程就是A線程最先運行，持有C,A對象鎖，後釋放A,C鎖，喚醒B。線程B等待A鎖，再申請B鎖，後打印B，再釋放B，A鎖，喚醒C，線程C等待B鎖，再申請C鎖，後打印C，再釋放C,B鎖，喚醒A。看起來似乎沒什麼問題，但如果你仔細想一下，就會發現有問題，就是初始條件，三個線程按照A,B,C的順序來啓動，按照前面的思考，A喚醒B，B喚醒C，C再喚醒A。但是這種假設依賴於JVM中線程調度、執行的順序。

【wait和sleep區別】
共同點：

1. 他們都是在多線程的環境下，都可以在程序的調用處阻塞指定的毫秒數，並返回。
2. wait()和sleep()都可以通過interrupt()方法 打斷線程的暫停狀態 ，從而使線程立刻拋出InterruptedException。
   如果線程A希望立即結束線程B，則可以對線程B對應的Thread實例調用interrupt方法。如果此刻線程B正在wait/sleep /join，則線程B會立刻拋出InterruptedException，在catch() {} 中直接return即可安全地結束線程。
   需要注意的是，InterruptedException是線程自己從內部拋出的，並不是interrupt()方法拋出的。對某一線程調用 interrupt()時，如果該線程正在執行普通的代碼，那麼該線程根本就不會拋出InterruptedException。但是，一旦該線程進入到 wait()/sleep()/join()後，就會立刻拋出InterruptedException 。
   不同點：
3. Thread類的方法：sleep(),yield()等
   Object的方法：wait()和notify()等
4. 每個對象都有一個鎖來控制同步訪問。Synchronized關鍵字可以和對象的鎖交互，來實現線程的同步。
   sleep方法沒有釋放鎖，而wait方法釋放了鎖，使得其他線程可以使用同步控制塊或者方法。
5. wait，notify和notifyAll只能在同步控制方法或者同步控制塊裏面使用，而sleep可以在任何地方使用
6. sleep必須捕獲異常，而wait，notify和notifyAll不需要捕獲異常

【總結】

• sleep（）方法

sleep()使當前線程進入停滯狀態（阻塞當前線程），讓出CUP的使用、目的是不讓當前線程獨自霸佔該進程所獲的CPU資源，以留一定時間給其他線程執行的機會;
　　
sleep()是Thread類的Static(靜態)的方法；因此他不能改變對象的機鎖，所以當在一個Synchronized塊中調用Sleep()方法是，線程雖然休眠了，但是對象的機鎖並木有被釋放，其他線程無法訪問這個對象（即使睡着也持有對象鎖）。

在sleep()休眠時間期滿後，該線程不一定會立即執行，這是因爲其它線程可能正在運行而且沒有被調度爲放棄執行，除非此線程具有更高的優先級。

• wait（）方法

wait()方法是Object類裏的方法；當一個線程執行到wait()方法時，它就進入到一個和該對象相關的等待池中，同時失去（釋放）了對象的機鎖（暫時失去機鎖，wait(longtimeout)超時時間到後還需要返還對象鎖）；其他線程可以訪問；

wait()使用notify或者notifyAlll或者指定睡眠時間來喚醒當前等待池中的線程。

wiat()必須放在synchronized block中，否則會在program runtime時扔出”java.lang.IllegalMonitorStateException“異常。

（七）.改變線程優先級

• Thread類提供了setPriority(int newPriority)來設置和返回線程的優先級，其中setPriority()方法的參數可以是一個整數，範圍是1—10之間。還有下面三個常量：
• MIN_PRIORITY = 1
  NORM_PRIORITY = 5
  MAX_PRIORITY = 10

（三）.常見線程名詞解釋和常用方法：

主線程：JVM調用程序main()所產生的線程。
當前線程：這個是容易混淆的概念。一般指通過Thread.currentThread()來獲取的進程。
後臺線程：指爲其他線程提供服務的線程，也稱爲守護線程。JVM的垃圾回收線程就是一個後臺線程。用戶線程和守護線程的區別在於，是否等待主線程依賴於主線程結束而結束
前臺線程：是指接受後臺線程服務的線程，其實前臺後臺線程是聯繫在一起，就像傀儡和幕後操縱者一樣的關係。傀儡是前臺線程、幕後操縱者是後臺線程。由前臺線程創建的線程默認也是前臺線程。可以通過isDaemon()和setDaemon()方法來判斷和設置一個線程是否爲後臺線程。

• sleep(): 強迫一個線程睡眠Ｎ毫秒。
  　　isAlive(): 判斷一個線程是否存活。
  　　join(): 等待線程終止。
  　　activeCount(): 程序中活躍的線程數。
  　　enumerate(): 枚舉程序中的線程。
  currentThread(): 得到當前線程。
  　　isDaemon(): 一個線程是否爲守護線程。
  　　setDaemon(): 設置一個線程爲守護線程。(用戶線程和守護線程的區別在於，是否等待主線程依賴於主線程結束而結束)
  　　setName(): 爲線程設置一個名稱。
  　　wait(): 強迫一個線程等待。
  　　notify(): 通知一個線程繼續運行。
  　　setPriority(): 設置一個線程的優先級。