线程的生命周期和状态控制
為什么80%的碼農都做不了架構師？>>> ??
一、線程的生命周期
線程狀態轉換圖：
其中Thread.join()調用的是Object.wait()方法實現的，意思是讓當前線程等待。是當前調用thread1.join()的線程等待，而不是讓thread1這個線程等待。
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并暫時停止自己的運行，進入阻塞狀態。阻塞的情況分三種：
（一）、等待阻塞：運行的線程執行wait()方法，JVM會把該線程放入等待池中。
（二）、同步阻塞：運行的線程在獲取對象的同步鎖時，若該同步鎖（synchronized）被別的線程占用，則JVM會把該線程放入鎖池中。
（三）、其他阻塞：運行的線程執行sleep()或join()方法，或者發出了I/O請求時，JVM會把該線程置為阻塞狀態。當sleep()狀態超時、join()等待線程終止或者超時、或者I/O處理完畢時，線程重新轉入就緒狀態。
在阻塞狀態的線程不能進入就緒隊列。只有當引起阻塞的原因消除時，如睡眠時間已到，或等待的I/O設備空閑下來，線程便轉入就緒狀態，重新到就緒隊列中排隊等待，被系統選中后從原來停止的位置開始繼續運行。有三種方法可以暫停Threads執行;
5、死亡狀態
當線程的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(); } } }二、線程狀態的控制
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); } } }運行結果:
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 {@Overridepublic 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(); } } } 運行結果:高級線程第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方法來控制并發線程的執行。
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 {@Overridepublic 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毫秒。
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);//設置線程的優先級 }@Overridepublic 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 - 如果當前線程無法修改該線程。
執行結果：
后臺線程第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;@Overridepublic void run() {while (true) {if (i == 10)break;i++;System.out.println(i);}} }或者
class MyThread extends Thread {int i = 0;boolean next = true;@Overridepublic void run() {while (next) {if (i == 10)next = false;i++;System.out.println(i);}} }或者
class MyThread extends Thread {int i = 0;@Overridepublic 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;@Overridepublic 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;@Overridepublic 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;@Overridepublic void run() { //ToDo:進行一些必要的初始化操作while (isRun) { //ToDo:執行你需要進行的異步操作} //ToDo:釋放線程占用的資源或者做必要的清除工作} }當滿足一定條件之后一般是在另外一個線程,比如主線程去設置當前線程可以結束了,將線程的運行標識符isRun設置為false.可以看到我對isRun使用了volatile關鍵字,讓其在線程間可見.同時在進入到while循環之前我們可以做一些線程的初始化操作,比如建立數據庫連接,初始化變量什么的,在線程將要結束退出while循環之后進行一些必要的釋放資源和清理工作.上面使用interrupt結束線程的方法我認為是很拙劣的,線程之所以會進入阻塞狀態就是因為當前線程還沒有進行完該線程該完成的任務,而你突然去中斷當前的線程會讓你的程序處于不可預知的狀態,同時無謂的sleep操作會造成無謂的頻繁的線程切換.
轉載于:https://my.oschina.net/fuyong/blog/727652
總結
以上是生活随笔為你收集整理的线程的生命周期和状态控制的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： RESTful API版本控制策略
- 下一篇： 解决ie7不支持after、before