java.lang.Thread類詳解

本文轉載自查看原文 2018-01-31 11:41 19047 Java/ Java並發編程

java.lang.Thread類詳解

一、前言

　　位於java.lang包下的Thread類是非常重要的線程類，它實現了Runnable接口，今天我們來學習一下Thread類，在學習Thread類之前，先介紹與線程相關知識：線程的幾種狀態、上下文切換，然后接着介紹Thread類中的方法的具體使用。

二、線程的狀態

　　在正式學習Thread類中的具體方法之前，我們先來了解一下線程有哪些狀態，這個將會有助於后面對Thread類中的方法的理解。

　　線程從創建到最終的消亡，要經歷若干個狀態。一般來說，線程包括以下這幾個狀態：創建(new)、就緒(runnable)、運行(running)、阻塞(blocked)、time waiting、waiting、消亡（dead）。

　　當需要新起一個線程來執行某個子任務時，就創建了一個線程。但是線程創建之后，不會立即進入就緒狀態，因為線程的運行需要一些條件（比如內存資源，譬如程序計數器、Java棧、本地方法棧都是線程私有的，所以需要為線程分配一定的內存空間），只有線程運行需要的所有條件滿足了，才進入就緒狀態。

　　當線程進入就緒狀態后，不代表立刻就能獲取CPU執行時間，也許此時CPU正在執行其他的事情，因此它要等待。當得到CPU執行時間之后，線程便真正進入運行狀態。

　　線程在運行狀態過程中，可能有多個原因導致當前線程不繼續運行下去，比如用戶主動讓線程睡眠（睡眠一定的時間之后再重新執行）、用戶主動讓線程等待，或者被同步塊給阻塞，此時就對應着多個狀態：time waiting（睡眠或等待一定的事件）、waiting（等待被喚醒）、blocked（阻塞）。

　　當由於突然中斷或者子任務執行完畢，線程就會被消亡。

　　下面這副圖描述了線程從創建到消亡之間的狀態：

　　在有些教程上將blocked、waiting、time waiting統稱為阻塞狀態，這個也是可以的，只不過這里我想將線程的狀態和Java中的方法調用聯系起來，所以將waiting和time waiting兩個狀態分離出來。

三、上下文切換

　　對於單核CPU來說（對於多核CPU，此處就理解為一個核），CPU在一個時刻只能運行一個線程，當在運行一個線程的過程中轉去運行另外一個線程，這個叫做線程上下文切換（對於進程也是類似）。

　　由於可能當前線程的任務並沒有執行完畢，所以在切換時需要保存線程的運行狀態，以便下次重新切換回來時能夠繼續切換之前的狀態運行。舉個簡單的例子：比如一個線程A正在讀取一個文件的內容，正讀到文件的一半，此時需要暫停線程A，轉去執行線程B，當再次切換回來執行線程A的時候，我們不希望線程A又從文件的開頭來讀取。

　　因此需要記錄線程A的運行狀態，那么會記錄哪些數據呢？因為下次恢復時需要知道在這之前當前線程已經執行到哪條指令了，所以需要記錄程序計數器的值，另外比如說線程正在進行某個計算的時候被掛起了，那么下次繼續執行的時候需要知道之前掛起時變量的值時多少，因此需要記錄CPU寄存器的狀態。所以一般來說，線程上下文切換過程中會記錄程序計數器、CPU寄存器狀態等數據。

　　說簡單點的：對於線程的上下文切換實際上就是存儲和恢復CPU狀態的過程，它使得線程執行能夠從中斷點恢復執行。

　　雖然多線程可以使得任務執行的效率得到提升，但是由於在線程切換時同樣會帶來一定的開銷代價，並且多個線程會導致系統資源占用的增加，所以在進行多線程編程時要注意這些因素。

四、Thread類中的方法

　　通過查看java.lang.Thread類的源碼可知：

　　Thread類實現了Runnable接口，在Thread類中，有一些比較關鍵的屬性，比如name是表示Thread的名字，可以通過Thread類的構造器中的參數來指定線程名字，priority表示線程的優先級（最大值為10，最小值為1，默認值為5），daemon表示線程是否是守護線程，target表示要執行的任務。

　　下面是Thread類中常用的方法：

　　以下是關系到線程運行狀態的幾個方法：

　　1）start方法

　　start()用來啟動一個線程，當調用start方法后，系統才會開啟一個新的線程來執行用戶定義的子任務，在這個過程中，會為相應的線程分配需要的資源。

　　2）run方法

　　run()方法是不需要用戶來調用的，當通過start方法啟動一個線程之后，當線程獲得了CPU執行時間，便進入run方法體去執行具體的任務。注意，繼承Thread類必須重寫run方法，在run方法中定義具體要執行的任務。

　　3）sleep方法

　　sleep方法有兩個重載版本：

1 2	`sleep(long` `millis)` `//參數為毫秒` `sleep(long` `millis,int` `nanoseconds)` `//第一參數為毫秒，第二個參數為納秒`

　　sleep相當於讓線程睡眠，交出CPU，讓CPU去執行其他的任務。

　　如果需要讓當前正在執行的線程暫停一段時間，並進入阻塞狀態，則可以通過調用Thread類的靜態sleep()方法來實現。

　　當當前線程調用sleep()方法進入阻塞狀態后，在其睡眠時間內，該線程不會獲得執行機會，即使系統中沒有其他可執行線程，處於sleep()中的線程也不會執行，因此sleep()方法常用來暫停程序的執行

　　但是有一點要非常注意，sleep方法不會釋放鎖，也就是說如果當前線程持有對某個對象的鎖，則即使調用sleep方法，其他線程也無法訪問這個對象。看下面這個例子就清楚了：

public class Test {

private int i = 10;

private Object object = new Object();

public static void main(String[] args) throws IOException {

Test test = new Test();

MyThread thread1 = test.new MyThread();

MyThread thread2 = test.new MyThread();

thread1.start();

thread2.start();

}

class MyThread extends Thread{

@Override

public void run() {

synchronized (object) {

i++;

System.out.println("i:"+i);

try {

System.out.println("線程"+Thread.currentThread().getName()+"進入睡眠狀態");

Thread.currentThread().sleep(10000);

} catch (InterruptedException e) {

// TODO: handle exception

}

System.out.println("線程"+Thread.currentThread().getName()+"睡眠結束");

i++;

System.out.println("i:"+i);

}

　　輸出結果：

　　從上面輸出結果可以看出，當Thread-0進入睡眠狀態之后，Thread-1並沒有去執行具體的任務。只有當Thread-0執行完之后，此時Thread-0釋放了對象鎖，Thread-1才開始執行。

　　注意，如果調用了sleep方法，必須捕獲InterruptedException異常或者將該異常向上層拋出。當線程睡眠時間滿后，不一定會立即得到執行，因為此時可能CPU正在執行其他的任務。所以說調用sleep方法相當於讓線程進入阻塞狀態。

　　4）yield方法

　　yield()方法和sleep()方法有點相似，它也是Thread類提供的一個靜態方法，它也可以讓當前正在執行的線程暫停，但它不會阻塞該線程，它只是將該線程轉入到就緒狀態。即讓當前線程暫停一下，讓系統的線程調度器重新調度一次，完全可能的情況是：當某個線程調用了yield()方法暫停之后，線程調度器又將其調度出來重新執行。

　　調用yield方法會讓當前線程交出CPU權限，讓CPU去執行其他的線程。它跟sleep方法類似，同樣不會釋放鎖。但是yield不能控制具體的交出CPU的時間，另外，當某個線程調用了yield()方法之后，只有優先級與當前線程相同或者比當前線程更高的處於就緒狀態的線程才會獲得執行機會。

　　注意，調用yield方法並不會讓線程進入阻塞狀態，而是讓線程重回就緒狀態，它只需要等待重新獲取CPU執行時間，這一點是和sleep方法不一樣的。

　　5）join方法

　　join方法有三個重載版本：

join()

join(long millis) //參數為毫秒

join(long millis,int nanoseconds) //第一參數為毫秒，第二個參數為納秒

　　假如在main線程中，調用thread.join方法，則main方法會等待thread線程執行完畢或者等待一定的時間。如果調用的是無參join方法，則等待thread執行完畢，如果調用的是指定了時間參數的join方法，則等待一定的事件。

　　看下面一個例子：

public class Test {

public static void main(String[] args) throws IOException {

System.out.println("進入線程"+Thread.currentThread().getName());

Test test = new Test();

MyThread thread1 = test.new MyThread();

thread1.start();

try {

System.out.println("線程"+Thread.currentThread().getName()+"等待");

thread1.join();

System.out.println("線程"+Thread.currentThread().getName()+"繼續執行");

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

class MyThread extends Thread{

@Override

public void run() {

System.out.println("進入線程"+Thread.currentThread().getName());

try {

Thread.currentThread().sleep(5000);

} catch (InterruptedException e) {

// TODO: handle exception

}

System.out.println("線程"+Thread.currentThread().getName()+"執行完畢");

}

　　輸出結果：

　　可以看出，當調用thread1.join()方法后，main線程會進入等待，然后等待thread1執行完之后再繼續執行。

　　實際上調用join方法是調用了Object的wait方法，這個可以通過查看源碼得知：

　　wait方法會讓線程進入阻塞狀態，並且會釋放線程占有的鎖，並交出CPU執行權限。

　　由於wait方法會讓線程釋放對象鎖，所以join方法同樣會讓線程釋放對一個對象持有的鎖。具體的wait方法使用在后面文章中給出。

　　6）interrupt方法

　　interrupt，顧名思義，即中斷的意思。單獨調用interrupt方法可以使得處於阻塞狀態的線程拋出一個異常，也就說，它可以用來中斷一個正處於阻塞狀態的線程；另外，通過interrupt方法和isInterrupted()方法來停止正在運行的線程。

　　下面看一個例子：

public class Test {

public static void main(String[] args) throws IOException {

Test test = new Test();

MyThread thread = test.new MyThread();

thread.start();

try {

Thread.currentThread().sleep(2000);

} catch (InterruptedException e) {

}

thread.interrupt();

}

class MyThread extends Thread{

@Override

public void run() {

try {

System.out.println("進入睡眠狀態");

Thread.currentThread().sleep(10000);

System.out.println("睡眠完畢");

} catch (InterruptedException e) {

System.out.println("得到中斷異常");

}

System.out.println("run方法執行完畢");

}

　　輸出結果：

　　從這里可以看出，通過interrupt方法可以中斷處於阻塞狀態的線程。那么能不能中斷處於非阻塞狀態的線程呢？看下面這個例子：

public class Test {

public static void main(String[] args) throws IOException {

Test test = new Test();

MyThread thread = test.new MyThread();

thread.start();

try {

Thread.currentThread().sleep(2000);

} catch (InterruptedException e) {

}

thread.interrupt();

}

class MyThread extends Thread{

@Override

public void run() {

int i = 0;

while(i<Integer.MAX_VALUE){

System.out.println(i+" while循環");

i++;

}

　　運行該程序會發現，while循環會一直運行直到變量i的值超出Integer.MAX_VALUE。所以說直接調用interrupt方法不能中斷正在運行中的線程。

　　但是如果配合isInterrupted()能夠中斷正在運行的線程，因為調用interrupt方法相當於將中斷標志位置為true，那么可以通過調用isInterrupted()判斷中斷標志是否被置位來中斷線程的執行。比如下面這段代碼：

public class Test {

public static void main(String[] args) throws IOException {

Test test = new Test();

MyThread thread = test.new MyThread();

thread.start();

try {

Thread.currentThread().sleep(2000);

} catch (InterruptedException e) {

}

thread.interrupt();

}

class MyThread extends Thread{

@Override

public void run() {

int i = 0;

while(!isInterrupted() && i<Integer.MAX_VALUE){

System.out.println(i+" while循環");

i++;

}

　　運行會發現，打印若干個值之后，while循環就停止打印了。

　　但是一般情況下不建議通過這種方式來中斷線程，一般會在MyThread類中增加一個屬性 isStop來標志是否結束while循環，然后再在while循環中判斷isStop的值。

class MyThread extends Thread{

private volatile boolean isStop = false;

@Override

public void run() {

int i = 0;

while(!isStop){

i++;

}

public void setStop(boolean stop){

this.isStop = stop;

}

　　那么就可以在外面通過調用setStop方法來終止while循環。

　　7）interrupted方法　　

　　interrupted()函數是Thread靜態方法，用來檢測當前線程的interrupt狀態，檢測完成后，狀態清空。通過下面的interrupted源碼我們能夠知道，此方法首先調用isInterrupted方法，而isInterrupted方法是一個重載的native方法private native boolean isInterrupted(boolean ClearInterrupted) 通過方法的注釋能夠知道，用來測試線程是否已經中斷，參數用來決定是否重置中斷標志。

 public static boolean interrupted() { return currentThread().isInterrupted(true); } public boolean isInterrupted() { return isInterrupted(false); } /** * Tests if some Thread has been interrupted. The interrupted state * is reset or not based on the value of ClearInterrupted that is * passed. */ private native boolean isInterrupted(boolean ClearInterrupted);