Java 的線程支持提供了一些便捷的工具方法，通過這些便捷的工具方法可以很好地控制線程的執(zhí)行。

join 線程

Thread 提供了讓一個線程等待另一個線程完成的方法—— join() 方法。當在某個程序執(zhí)行流中調用其他線程的 join() 方法時，調用線程將被阻塞，直到被 join() 方法加入的 join 線程執(zhí)行完為止。

join() 方法通常由使用線程的程序調用，以將大問題劃分成許多小問題，每個小問題分配一個線程。當所有的小問題都得到處理后，再調用主線程來進一步操作。

public class JoinThread extends Thread{ // 提供一個有參數的構造器，用于設置該線程的名字 public JoinThread(String name) { super(name); } //重寫run()方法，定義線程執(zhí)行體 public void run() { for (int i=0 ; i < 100; i++) { System.out.println(this.getName() + ' ' + i); } } public static void main(String[] args) throws Exception { //啟動子線程 new JoinThread('新線程').start(); for(int i=0 ; i < 100; i++) { if(i==20) {JoinThread jt = new JoinThread('被Join的線程');jt.start();// main線程調用了 jt 線程的 join() 方法// main線程必須等jt執(zhí)行結束后才會向下執(zhí)行jt.join(); } System.out.println(Thread.currentThread().getName() + ' ' + i); } }}

上面程序中一共有3個線程，主方法開始時就啟動了名為“新線程”的子線程，該子線程將會和 main 線程并發(fā)執(zhí)行。當主線程的循環(huán)變量 i 等于20時，啟動了名為“被 Join 的線程”的線程，該線程不會和 main 線程并發(fā)執(zhí)行 ， main 線程必須等該線程執(zhí)行結束后才可以向下執(zhí)行。在名為“被 Join 的線程”的線程執(zhí)行時，實際上只有2個子線程并發(fā)執(zhí)行，而主線程處于等待狀態(tài)。運行上面程序，會看到如下圖所示的運行效果。

主線程執(zhí)行到 i == 20時，程序啟動并 join 了名為“被 Join 的線程”的線程，所以主線程將一直處于阻塞狀態(tài)，直到名為“被 Join 的線程”的線程執(zhí)行完成。

join() 方法有如下三種重載形式：

join()：等待被 join 的線程執(zhí)行完成。 join(long millis)：等待被 join 的線程的時間最長為 millis 毫秒。如果在 millis 毫秒內被 join 的線程還沒有執(zhí)行結束，則不再等待。 join(long millis, int nanos)：等待被 join 的線程的時間最長為 millis 毫秒加 nanos 毫微秒。

提示：通常很少使用第三種形式，原因有兩個：程序對時間的精度無須精確到毫微秒；計算機硬件、操作系統本身也無法精確到毫微秒。

后臺線程

有一種線程，它是在后臺運行的，它的任務是為其他的線程提供服務，這種線程被稱為“后臺線程（Daemon Thread）”，又稱為“守護線程”或“精靈線程”。 JVM 的垃圾回收線程就是典型的后臺線程。

后臺線程有個特征：如果所有的前臺線程都死亡，后臺線程會自動死亡。

調用 Thread 對象的 setDaemon(true) 方法可將指定線程設置成后臺線程。下面程序將執(zhí)行線程設置成后臺線程，可以看到當所有的前臺線程死亡時，后臺線程隨之死亡。當整個虛擬機中只剩下后臺線程時，程序就沒有繼續(xù)運行的必要了，所以虛擬機也就退出了。

public class DaemonThread extends Thread { // 定義后臺線程的線程執(zhí)行體與普通線程沒有任何區(qū)別 public void run() { for (int i=0 ; i < 1000; i++) { System.out.println(this.getName() + ' ' + i); } } public static void main(String[] args) { DaemonThread t = new DaemonThread(); // 將此線程設置為后臺線程 t.setDaemon(true); // 啟動后臺線程 t.start(); for (int i=0; i < 100; i++) { System.out.println(Thread.currentThread().getName() + ' ' + i); } // ---------程序執(zhí)行到此處，前臺線程（main線程）結束---------- // 后臺線程也應該隨之結束}}

上面程序中的粗體字代碼先將t線程設置成后臺線程，然后啟動該線程，本來該線程應該執(zhí)行到 i 等于999時才會結束，但運行程序時不難發(fā)現該后臺線程無法運行到999，因為當主線程也就是程序中唯一的前臺線程運行結束后，JVM 會主動退出，因而后臺線程也就被結束了。

Thread 類還提供了一個 isDaemon() 方法，用于判斷指定線程是否為后臺線程。

從上面程序可以看出，主線程默認是前臺線程，t線程默認也是前臺線程。并不是所有的線程默認都是前臺線程，有些線程默認就是后臺線程——前臺線程創(chuàng)建的子線程默認是前臺線程，后臺線程創(chuàng)建的子線程默認是后臺線程。

注意：前臺線程死亡后， JVM 會通知后臺線程死亡，但從它接收指令到做出響應，需要一定時間。而且要將某個線程設置為后臺線程，必須在該線程啟動之前設置，也就是說，setDaemon(true) 必須在 start() 方法之前調用，否則會引發(fā) IllegalThreadStateException異常。

線程睡眠：sleep

如果需要讓當前正在執(zhí)行的線程暫停一段時間，并進入阻塞狀態(tài)，則可以通過調用 Thread 類的靜態(tài) sleep() 方法來實現。sleep() 方法有兩種重載形式。

static void sleep(long millis)：讓當前正在執(zhí)行的線程暫停millis毫秒，并進入阻塞狀態(tài)，該方法受到系統計時器和線程調度器的精度與準確度的影響。 static void sleep(long millis, int nanos)：讓當前正在執(zhí)行的線程暫停 millis 毫秒加 nanos 毫微秒，并進入阻塞狀態(tài)，該方法受到系統計時器和線程調度器的精度與準確度的影響。

與前面類似的是，程序很少調用第二種形式的 sleep() 方法。

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

下面程序調用 sleep() 方法來暫停主線程的執(zhí)行，因為該程序只有一個主線程，當主線程進入睡眠后，系統沒有可執(zhí)行的線程，所以可以看到程序在 sleep() 方法處暫停。

public class SleepTest { public static void main(String[] args) throws Exception { for(int i=0;i<10;i++) { System.out.println('當前時間：'+new Date()); // 調用sleep() 方法讓當前線程暫停1s Thread.sleep(1000); } }}

上面程序中的粗體字代碼將當前執(zhí)行的線程暫停 1 秒，運行上面程序，看到程序依次輸出10條字符串，輸出2條字符串之間的時間間隔為1秒。

線程讓步： yield

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

實際上，當某個線程調用了 yield() 方法暫停之后，只有優(yōu)先級與當前線程相同，或者優(yōu)先級比當前線程更高的處于就緒狀態(tài)的線程才會獲得執(zhí)行的機會。下面程序使用 yield() 方法來讓當前正在執(zhí)行的線程暫停。

public class YieldTest extends Thread{ public YieldTest(String name) { super(name); } // 定義run()方法作為線程執(zhí)行體 public void run() { for(int i=0;i<50;i++) { System.out.println(getName()+' '+i); // 當 i等于20時，使用 yield() 方法讓當前線程讓步 if(i==20) {Thread.yield(); } } } public static void main(String[] args) { // 啟動兩個并發(fā)線程 YieldTest yt1 = new YieldTest('高級'); // 將yt1線程設置成最高優(yōu)先級 // yt1.setPriority(Thread.MAX_PRIORITY); yt1.start(); YieldTest yt2 = new YieldTest('低級'); // 將yt2線程設置成最低優(yōu)先級 // yt2.setPriority(Thread.MIN_PRIORITY); yt2.start(); }}

注意：在多 CPU 并行的環(huán)境下， yield() 方法的功能有時候并不明顯。

關于 sleep() 方法和 yield() 方法的區(qū)別如下。

sleep() 方法暫停當前線程后，會給其他線程執(zhí)行機會，不會理會其他線程的優(yōu)先級；但 yield() 方法只會給優(yōu)先級相同，或優(yōu)先級更高的線程執(zhí)行機會。 sleep() 方法會將線程轉入阻塞狀態(tài)，直到經過阻塞時間才會轉入就緒狀態(tài)；而 yield() 不會將線程轉入阻塞狀態(tài)，它只是強制當前線程進入就緒狀態(tài)。因此完全有可能某個線程調用 yield() 方法暫停之后，立即再次獲得處理器資源被執(zhí)行。 sleep() 方法聲明拋出了 InterruptedException 異常，所以調用 sleep() 方法時要么捕捉該異常，要么顯式聲明拋出該異常；而 yield ()方法則沒有聲明拋出任何異常。 sleep() 方法比 yield() 方法有更好的可移植性，通常不建議使用 yield() 方法來控制并發(fā)線程的執(zhí)行。

改變線程優(yōu)先級

每個線程執(zhí)行時都具有一定的優(yōu)先級，優(yōu)先級高的線程獲得較多的執(zhí)行機會，而優(yōu)先級低的線程則獲得較少的執(zhí)行機會。

每個線程默認的優(yōu)先級都與創(chuàng)建它的父線程的優(yōu)先級相同，在默認情況下， main 線程具有普通優(yōu)先級，由 main 線程創(chuàng)建的子線程也具有普通優(yōu)先級。

Thread 類提供了 setPriority(int newPriority)、 getPriority() 方法來設置和返回指定線程的優(yōu)先級，其中 setPriority() 方法的參數可以是一個整數，范圍是1~10之間，也可以使用 Thread 類的如下三個靜態(tài)常量。

MAX _ PRIORITY：其值是 10。 MIN _ PRIORITY：其值是 1 。 NORM _ PRIORITY：其值是 5。

下面程序使用了 setPriority() 方法來改變主線程的優(yōu)先級，并使用該方法改變了兩個線程的優(yōu)先級，從而可以看到高優(yōu)先級的線程將會獲得更多的執(zhí)行機會。

public class PriorityTest extends Thread{ public PriorityTest(String name) { super(name); } public void run() { for(int i=0;i<50;i++) { System.out.println(getName()+'，其優(yōu)先級是：'+getPriority()+'，循環(huán)變量的值為：'+i); } } public static void main(String[] args) { // 改變主線程的優(yōu)先級 Thread.currentThread().setPriority(6); for(int i=0;i<30;i++) { if(i==10) {PriorityTest low = new PriorityTest('低級');low.start();System.out.println('創(chuàng)建之初的優(yōu)先級：'+low.getPriority());// 設置該線程為最低優(yōu)先級low.setPriority(Thread.MIN_PRIORITY); } if(i==20) {PriorityTest high = new PriorityTest('高級');high.start();System.out.println('創(chuàng)建之初的優(yōu)先級：'+high.getPriority());// 設置該線程為最高優(yōu)先級high.setPriority(Thread.MAX_PRIORITY); } } }}

上面程序中的第一行粗體字代碼改變了主線程的優(yōu)先級為6，這樣由main線程所創(chuàng)建的子線程的優(yōu)先級默認都是6，所以程序直接輸出 low、high 兩個線程的優(yōu)先級時應該看到6。接著程序將 low 線程的優(yōu)先級設為 Priority.MIN_PRIORITY，將 high 線程的優(yōu)先級設置為 Priority.MAX_PRIORITY。

運行上面程序，會看到如下圖所示的效果。

值得指出的是，雖然 Java 提供了 10 個優(yōu)先級級別，但這些優(yōu)先級級別需要操作系統的支持。遺憾的是，不同操作系統上的優(yōu)先級并不相同，而且也不能很好地和 Java 的10個優(yōu)先級對應，例如 Windows 2000 僅提供了 7個優(yōu)先級。因此應該盡量避免直接為線程指定優(yōu)先級，而應該使用 MAX_PRIORITY、MIN_PRIORITY 和 NORM_PRIORITY 三個靜態(tài)常量來設置優(yōu)先級，這樣才可以保證程序具有最好的可移植性。

以上就是Java 控制線程的方法的詳細內容，更多關于Java 控制線程的資料請關注好吧啦網其它相關文章！