Java 多執行緒（三）—— 執行緒的生命週期及方法

這篇部落格介紹執行緒的生命週期。

執行緒是一個動態執行的過程，它也有從建立到死亡的過程。

執行緒的幾種狀態

在 Thread 類中，有一個列舉內部類：

上面的資訊以圖片表示如下：

第一張圖：

第二張圖：把等待、計時等待、阻塞看成阻塞一個狀態了

1、新建狀態（new）:使用 new 建立一個執行緒，僅僅只是在堆中分配了記憶體空間

新建狀態下，執行緒還沒有呼叫 start()方法啟動，只是存在一個執行緒物件而已

Thread t = new Thread();//這就是t執行緒的新建狀態

2、可執行狀態（runnable）：新建狀態呼叫 start() 方法，進入可執行狀態。而這個又分成兩種狀態，ready 和 running，分別表示就緒狀態和執行狀態

就緒狀態：執行緒物件呼叫了 start() 方法，等待 JVM 的排程，（此時該執行緒並沒有執行）

執行狀態：執行緒物件獲得 JVM 排程，如果存在多個 CPU，那麼執行多個執行緒並行執行

注意：執行緒物件只能呼叫一次 start() 方法，否則報錯：illegaThreadStateExecptiong

3、阻塞狀態（blocked）:正在執行的執行緒因為某種原因放棄 CPU，暫時停止執行，就會進入阻塞狀態。此時 JVM 不會給執行緒分配 CPU，知道執行緒重新進入就緒狀態，才有機會轉到 執行狀態。

注意：阻塞狀態只能先進入就緒狀態，不能直接進入執行狀態

阻塞狀態分為兩種情況：

①、當執行緒 A 處於可執行狀態中，試圖獲取同步鎖時，卻被 B 執行緒獲取，此時 JVM 把當前 A 執行緒放入鎖池中，A執行緒進入阻塞狀態

②、當執行緒處於執行狀態時，發出了 IO 請求，此時進入阻塞狀態

4、等待狀態（waiting）:等待狀態只能被其他執行緒喚醒，此時使用的是無引數的 wait() 方法

①、當執行緒處於執行狀態時，呼叫了 wait() 方法，此時 JVM 把該執行緒放入等待池中

5、計時等待（timed waiting）:呼叫了帶引數的 wait（long time）或 sleep(long time) 方法

①、當執行緒處於執行狀態時，呼叫了帶引數 wait 方法，此時 JVM 把該執行緒放入等待池中

②、當前執行緒呼叫了 sleep(long time) 方法

6、終止狀態（terminated）:通常稱為死亡狀態，表示執行緒終止

①、正常終止，執行完 run() 方法，正常結束

②、強制終止，如呼叫 stop() 方法或 destory() 方法

③、異常終止，執行過程中發生異常

執行緒的方法

1、sleep(long millis)

執行緒休眠：讓執行的執行緒暫停一段時間，進入計時等待狀態。

static void sleep(long millis):呼叫此方法後，當前執行緒放棄 CPU 資源，在指定的時間內，sleep 所在的執行緒不會獲得可執行的機會，此狀態下的執行緒不會釋放同步鎖。

該方法更多的是用來模擬網路延遲，讓多執行緒併發訪問同一資源時的錯誤效果更加明顯。

2、wait()

執行緒等待：一旦一個執行緒執行到wait(),就釋放當前的鎖。

注意：此方法必須在同步程式碼塊或同步方法中

3、notify()/notifyAll()

喚醒：喚醒wait的一個或所有的執行緒

    注意：此方法需和wait()成對使用，必須在同步程式碼塊或同步方法中

注意 sleep() 和 wait() 的區別，sleep指定時間內當前執行緒放棄 CPU 資源，執行緒不會釋放同步鎖，wait 會放棄 CPU 資源，同時也會放棄 同步鎖

4、join()

聯合執行緒：表示這個執行緒等待另一個執行緒完成後（死亡）才執行，join 方法被呼叫之後，執行緒物件處於阻塞狀態。寫在哪個執行緒中，哪個執行緒阻塞

這種也稱為聯合執行緒，就是說把當前執行緒和當前執行緒所在的執行緒聯合成一個執行緒

5、 yield()

禮讓執行緒：表示當前執行緒物件提示排程器自己願意讓出 CPU 資源。

呼叫該方法後，執行緒物件進入就緒狀態，所以完全有可能：某個執行緒呼叫了 yield() 方法，但是執行緒排程器又把它排程出來重新執行。

public class TestThread1 {
public static void main(String [] args){
SubThread1 subThread1=new SubThread1();
subThread1.start();
for (int i=0;i<=100;i++){ 
System.out.println(Thread.currentThread().getName()+":"+i);
if(i==20){
try {
subThread1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}

class SubThread1 extends Thread{
@Override
public void run(){
for (int i=0;i<=100;i++){
try {
Thread.currentThread().sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}

main:0
main:1
main:2
main:3
main:4
main:5
main:6
main:7
main:8
main:9
main:10
Thread-0:0
Thread-0:1
Thread-0:2
Thread-0:3
Thread-0:4
Thread-0:5
Thread-0:6
Thread-0:7
Thread-0:8
Thread-0:9
Thread-0:10
.
.
.
Thread-0:99
Thread-0:100
main:11
main:12
main:13
main:14
main:15
.
.
main:98
main:99
main:100

 執行緒的通訊

/**
 * @author: ChenHao
 * @Description:使用兩個執行緒列印1-100，執行緒1，執行緒2交替列印
 * 執行緒通訊：如下的三個關鍵字使用的話，都得在同步程式碼塊或同步方法中。
 * wait():一旦一個執行緒執行到wait(),就釋放當前的鎖。
 * notify()/notifyAll():喚醒wait的一個或所有的執行緒
 * 如果不使用break，程式將不會停止
 * @Date: Created in 10:50 2018/10/29
 */
public class TestPrintNum {
public static void main(String [] args){
PrintNum printNum=new PrintNum();
Thread thread1=new Thread(printNum);
Thread thread2=new Thread(printNum);
thread1.start();
thread2.start();
}
}

class PrintNum implements Runnable{
int num=1;
@Override
public void run(){
while (true){
synchronized (this){
notify();
if(num<=100){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+num++);
}else {
break;
}
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}

執行結果：

Thread-0:1
Thread-1:2
Thread-0:3
Thread-1:4
Thread-0:5
Thread-1:6
Thread-0:7
Thread-1:8
Thread-0:9
Thread-1:10
.
.
.

執行結果分析：當第一個執行緒獲取鎖之後，列印後wait,釋放鎖；第二個執行緒獲取鎖，並喚醒第一個執行緒，列印後wait；交替列印