線程的生命週期和狀態控制
1、線程的生命週期html
線程狀態轉換圖：java
其中Thread.join()調用的是Object.wait()方法實現的，意思是讓當前線程等待。是當前調用thread1.join()的線程等待，而不是讓thread1這個線程等待。程序員
一、新建狀態數據庫
用new關鍵字和Thread類或其子類創建一個線程對象後，該線程對象就處於新生狀態。處於新生狀態的線程有本身的內存空間，經過調用start方法進入就緒狀態（runnable）。安全
注意：不能對已經啓動的線程再次調用start()方法，不然會出現java.lang.IllegalThreadStateException異常。多線程
2、就緒狀態併發
處於就緒狀態的線程已經具有了運行條件，但尚未分配到CPU，處於線 程就緒隊列（儘管是採用隊列形式，事實上，把它稱爲可運行池而不是可運行隊列。由於cpu的調度不必定是按照先進先出的順序來調度的），等待系統爲其分配 CPU。等待狀態並非執行狀態，當系統選定一個等待執行的Thread對象後，它就會從等待執行狀態進入執行狀態，系統挑選的動做稱之爲「cpu調 度」。一旦得到CPU，線程就進入運行狀態並自動調用本身的run方法。異步
提示：若是但願子線程調用start()方法後當即執行，可使用Thread.sleep()方式使主線程睡眠一夥兒，轉去執行子線程。編輯器
三、運行狀態ide
處於運行狀態的線程最爲複雜，它能夠變爲阻塞狀態、就緒狀態和死亡狀態。
處於就緒狀態的線程，若是得到了cpu的調度，就會從就緒狀態變爲運行狀態，執行run()方法中的任務。若是該線程失去了cpu資源，就會又從運 行狀態變爲就緒狀態。從新等待系統分配資源。也能夠對在運行狀態的線程調用yield()方法，它就會讓出cpu資源，再次變爲就緒狀態。
當發生以下狀況是，線程會從運行狀態變爲阻塞狀態：
①、線程調用sleep方法主動放棄所佔用的系統資源
②、線程調用一個阻塞式IO方法，在該方法返回以前，該線程被阻塞
③、線程試圖得到一個同步監視器，但更改同步監視器正被其餘線程所持有
④、線程在等待某個通知（notify）
⑤、程序調用了線程的suspend方法將線程掛起。不過該方法容易致使死鎖，因此程序應該儘可能避免使用該方法。
當線程的run()方法執行完，或者被強制性地終止，例如出現異常，或者調用了stop()、desyory()方法等等，就會從運行狀態轉變爲死亡狀態。
四、阻塞狀態
處於運行狀態的線程在某些狀況下，如執行了sleep（睡眠）方法，或等待I/O設備等資源，將讓出CPU並暫時中止本身的運行，進入阻塞狀態。阻塞的狀況分三種：
（一）、等待阻塞：運行的線程執行wait()方法，JVM會把該線程放入等待池中。
（二）、同步阻塞：運行的線程在獲取對象的同步鎖時，若該同步鎖（synchronized）被別的線程佔用，則JVM會把該線程放入鎖池中。
（三）、其餘阻塞：運行的線程執行sleep()或join()方法，或者發出了I/O請求時，JVM會把該線程置爲阻塞狀態。當sleep()狀態超時、join()等待線程終止或者超時、或者I/O處理完畢時，線程從新轉入就緒狀態。
在阻塞狀態的線程不能進入就緒隊列。只有當引發阻塞的緣由消除時，如睡眠時間已到，或等待的I/O設備空閒下來，線程便轉入就緒狀態，從新到就緒隊列中排隊等待，被系統選中後從原來中止的位置開始繼續運行。有三種方法能夠暫停Threads執行;
五、死亡狀態
當線程的run()方法執行完，或者因異常退出而被強制性地終止，就認爲它死去。這個線程對象也許是活的，可是，它已經不是一個單獨執行的線程。線程一旦死亡， 就不能復生。 若是在一個死去的線程上調用start()方法，會拋出java.lang.IllegalThreadStateException異常。
鎖池：Java多線程中有兩種同步鎖synchronized和Lock，其中Lock關鍵字是JDK1.5以後新加入的鎖，鎖具備排他性，當一個線程得到鎖以後，其餘線程只能等待其餘線程釋放該鎖，等待的線程也就進入了鎖池。
等待池：當線程調用Object.wait()或者Condition.await()時，程序所在的線程會釋放其所佔有的資源（相應的會釋放 synchronized和Lock鎖），而進入等待池，等待池當中的線程會等待其餘線程調用 Object.notifyAll()，Object.notify()或 者 Condition.signalAll()，Condition.signal()喚醒，這樣進入等待的線程就進入等待池，從等待池出來以後進入鎖池，得到鎖以後即可進行工做了。
須要說明的是，synchronized鎖和調用wait()的對象應爲同一對象！不然會報java.lang.IllegalMonitorStateException錯誤。正確方式以下：
public synchronized static void function04() { //類鎖
try {
Test05.class.wait();//本類的wait池
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void function02() {
synchronized (lock) {//lock鎖
try {
lock.wait();//一樣爲lock鎖的wait池
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
2、線程狀態的控制
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()等間接控制方法。
一、線程睡眠——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);
}
}
}
運行結果:
main
Thread-0線程0次執行！
Thread-0線程1次執行！
Thread-0線程2次執行！
main0
main1
......
②、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的順序執行的。
二、線程讓步——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();
}
}
}
運行結果:
高級線程第0次執行！
高級線程第1次執行！
高級線程第2次執行！
高級線程第3次執行！
高級線程第4次執行！
中級線程第0次執行！
低級線程第0次執行！
低級線程第1次執行！
低級線程第2次執行！
低級線程第3次執行！
低級線程第4次執行！
中級線程第1次執行！
中級線程第2次執行！
中級線程第3次執行！
中級線程第4次執行！
......
關於sleep()方法和yield()方的區別以下：
①、sleep方法暫停當前線程後，會進入阻塞狀態，只有當睡眠時間到了，纔會轉入就緒狀態。而yield方法調用後 ，是直接進入就緒狀態，因此有可能剛進入就緒狀態，又被調度到運行狀態。
②、sleep方法聲明拋出了InterruptedException，因此調用sleep方法的時候要捕獲該異常，或者顯示聲明拋出該異常。而yield方法則沒有聲明拋出任務異常。
③、sleep方法比yield方法有更好的可移植性，一般不要依靠yield方法來控制併發線程的執行。
三、線程合併——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-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次執行！
main線程第0次執行！
Thread-0線程第10次執行！
main線程第1次執行！
......
在這個例子中，在主線程中調用thread.join(); 就是將主線程加入到thread子線程後面等待執行。不過有時間限制，爲1毫秒。
四、線程的優先級
每一個線程執行時都有一個優先級的屬性，優先級高的線程能夠得到較多的執行機會，而優先級低的線程則得到較少的執行機會。與線程休眠相似，線程的優先級仍然沒法保障線程的執行次序。只不過，優先級高的線程獲取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三個靜態常量來設定優先級，這樣 才能保證程序最好的可移植性。
五、守護線程
守護線程與普通線程寫法上基本麼啥區別，調用線程對象的方法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的垃圾回收也是一個守護線程。守護線
的好處就是你不須要關心它的結束問題。例如你在你的應用程序運行的時候但願播放背景音樂，若是將這個播放背景音樂的線程設定爲非守護線程，那麼在用戶請求退出的時候，
不只要退出主線程，還要通知播放背景音樂的線程退出；若是設定爲守護線程則不須要了。
六、如何結束一個線程
Thread.stop()、Thread.suspend、Thread.resume、Runtime.runFinalizersOnExit這些終止線程運行的方法已經被廢棄了，使用它們是極端不安全的！想要安全有效的結束一個線程，可使用下面的方法。
一、正常執行完run方法，而後結束掉
二、控制循環條件和判斷條件的標識符來結束掉線程
好比說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)的無線循環。
三、使用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異常。
我我的比較推崇的作法是使用標識符來標識當前線程的運行狀態:
class MyThread extends Thread {
public volatile boolean isRun = true;
@Override
public void run() {
//ToDo:進行一些必要的初始化操做
while (isRun) {
//ToDo:執行你須要進行的異步操做
}
//ToDo:釋放線程佔用的資源或者作必要的清除工做
}
}
當知足必定條件以後通常是在另一個線程,好比主線程去設置當前線程能夠結束了,將線程的運行標識符isRun設置爲false.能夠看到我對isRun使用了volatile關鍵字,讓其在線程間可見.同時在進入到while循環以前咱們能夠作一些線程的初始化操做,好比創建數據庫鏈接,初始化變量什麼的,在線程將要結束退出while循環以後進行一些必要的釋放資源和清理工做.上面使用interrupt結束線程的方法我認爲是很拙劣的,線程之因此會進入阻塞狀態就是由於當前線程尚未進行完該線程該完成的任務,而你忽然去中斷當前的線程會讓你的程序處於不可預知的狀態,同時無謂的sleep操做會形成無謂的頻繁的線程切換.
- 1. Java多線程、線程的生命週期和狀態控制
- 2. 線程的生命週期和狀態
- 3. Java多線程（二）、線程的生命週期和狀態控制
- 4. 線程的生命週期與狀態
- 5. 線程生命週期(狀態)
- 6. 多線程--生命週期 狀態圖
- 7. [java] 線程的生命週期和各狀態的轉換
- 8. Java線程的創建、線程的生命週期狀態
- 9. 線程的狀態/線程的生命週期
- 10. 線程的生命週期（線程間的狀態轉換）
- 更多相關文章...
- • Spring Bean的生命週期 - Spring教程
- • Rust 生命週期 - RUST 教程
- • 適用於PHP初學者的學習線路和建議
- • 漫談MySQL的鎖機制
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Java多線程、線程的生命週期和狀態控制
- 2. 線程的生命週期和狀態
- 3. Java多線程（二）、線程的生命週期和狀態控制
- 4. 線程的生命週期與狀態
- 5. 線程生命週期(狀態)
- 6. 多線程--生命週期 狀態圖
- 7. [java] 線程的生命週期和各狀態的轉換
- 8. Java線程的創建、線程的生命週期狀態
- 9. 線程的狀態/線程的生命週期
- 10. 線程的生命週期（線程間的狀態轉換）