Java多線程編程詳解

1、Java多線程編程詳解目 錄 TOC o 1-3 h z u HYPERLINK l _Toc280883512 Java多線程編程詳解 PAGEREF _Toc280883512 h 1 HYPERLINK l _Toc280883513 線程簡介 PAGEREF _Toc280883513 h 1 HYPERLINK l _Toc280883514 一、線程概述 PAGEREF _Toc280883514 h 1 HYPERLINK l _Toc280883515 二、線程給我們帶來的好處 PAGEREF _Toc280883515 h 2 HYPERLINK l _Toc28088351

2、6 三、Java的線程模型 PAGEREF _Toc280883516 h 4 HYPERLINK l _Toc280883517 用Thread類創(chuàng)建線程 PAGEREF _Toc280883517 h 4 HYPERLINK l _Toc280883518 用Runnable接口創(chuàng)建線程 PAGEREF _Toc280883518 h 8 HYPERLINK l _Toc280883519 線程的生命周期 PAGEREF _Toc280883519 h 9 HYPERLINK l _Toc280883520 一、創(chuàng)建并運行線程 PAGEREF _Toc280883520 h 10 HYPE

3、RLINK l _Toc280883521 二、掛起和喚醒線程 PAGEREF _Toc280883521 h 11 HYPERLINK l _Toc280883522 三、終止線程的三種方法 PAGEREF _Toc280883522 h 12 HYPERLINK l _Toc280883523 Join()方法的使用 PAGEREF _Toc280883523 h 15 HYPERLINK l _Toc280883524 慎重使用volatile關鍵字 PAGEREF _Toc280883524 h 17 HYPERLINK l _Toc280883525 向線程傳遞數(shù)據的三種方法 PAG

4、EREF _Toc280883525 h 19 HYPERLINK l _Toc280883526 一、通過構造方法傳遞數(shù)據 PAGEREF _Toc280883526 h 20 HYPERLINK l _Toc280883527 二、通過變量和方法傳遞數(shù)據 PAGEREF _Toc280883527 h 20 HYPERLINK l _Toc280883528 三、通過回調函數(shù)傳遞數(shù)據 PAGEREF _Toc280883528 h 21 HYPERLINK l _Toc280883529 從線程返回數(shù)據的兩種方法 PAGEREF _Toc280883529 h 23 HYPERLINK l

5、 _Toc280883530 一、通過類變量和方法返回數(shù)據 PAGEREF _Toc280883530 h 23 HYPERLINK l _Toc280883531 二、通過回調函數(shù)返回數(shù)據 PAGEREF _Toc280883531 h 25 HYPERLINK l _Toc280883532 為什么要進行數(shù)據同步（加鎖） PAGEREF _Toc280883532 h 25 HYPERLINK l _Toc280883533 使用synchronized關鍵字同步類方法 PAGEREF _Toc280883533 h 28 HYPERLINK l _Toc280883534 在使用sync

6、hronized關鍵字時有以下四點需要注意： PAGEREF _Toc280883534 h 32 HYPERLINK l _Toc280883535 使用synchronized的塊同步 PAGEREF _Toc280883535 h 35 HYPERLINK l _Toc280883536 一、非靜態(tài)類方法的同步 PAGEREF _Toc280883536 h 35 HYPERLINK l _Toc280883537 二、靜態(tài)類方法的同步 PAGEREF _Toc280883537 h 37 HYPERLINK l _Toc280883538 使用synchronized塊同步變量 PAG

7、EREF _Toc280883538 h 39線程簡介一、線程概述 線程是程序運行的基本執(zhí)行單元。當操作系統(tǒng)（不包括單線程的操作系統(tǒng)，如微軟早期的DOS）在執(zhí)行一個程序時，會在系統(tǒng)中建立一個進程，而在這個進程中，必須至少建立一個線程（這個線程被稱為主線程）來作為這個程序運行的入口點。因此，在操作系統(tǒng)中運行的任何程序都至少有一個主線程。 進程和線程是現(xiàn)代操作系統(tǒng)中兩個必不可少的運行模型。在操作系統(tǒng)中可以有多個進程，這些進程包括系統(tǒng)進程（由操作系統(tǒng)內部建立的進程）和用戶進程（由用戶程序建立的進程）；一個進程中可以有一個或多個線程。進程和進程之間不共享內存，也就是說系統(tǒng)中的進程是在各自獨立的內存空間

8、中運行的。而一個進程中的線可以共享系統(tǒng)分派給這個進程的內存空間。 線程不僅可以共享進程的內存，而且還擁有一個屬于自己的內存空間，這段內存空間也叫做線程棧， 是在建立線程時由系統(tǒng)分配的，主要用來保存線程內部所使用的數(shù)據，如線程執(zhí)行函數(shù)中所定義的變量。 注意：任何一個線程在建立時都會執(zhí)行一個函數(shù)，這個函數(shù)叫做線程執(zhí)行函數(shù)。也可以將這個函數(shù)看做線程的入口點（類似于程序中的main函數(shù)）。無論使用什么語言或技術來建立線程，都必須執(zhí)行這個函數(shù)（這個函數(shù)的表現(xiàn)形式可能不一樣，但都會有一個這樣的函數(shù)）。如在 HYPERLINK / t _blank Windows中用于建立線程的API函數(shù)CreateThr

9、ead的第三個參數(shù)就是這個執(zhí)行函數(shù)的指針。 在操作系統(tǒng)將進程分成多個線程后，這些線程可以在操作系統(tǒng)的管理下并發(fā)執(zhí)行，從而大大提高了程序的運行效率。雖然線程的執(zhí)行從宏觀上看是多個線程同時執(zhí)行，但實際上這只是操作系統(tǒng)的障眼法。由于一塊CPU同時只能執(zhí)行一條指令，因此，在擁有一塊CPU的計算機上不可能同時執(zhí)行兩個任務。而操作系統(tǒng)為了能提高程序的運行效率，在一個線程空閑時會撤下這個線程，并且會讓其他的線程來執(zhí)行，這種方式叫做線程調度。我們之所以從表面上看是多個線程同時執(zhí)行，是因為不同線程之間切換的時間非常短，而且在一般情況下切換非常頻繁。假設我們有線程A和B.在運行時，可能是A執(zhí)行了1毫秒后，切換到B

10、后，B又執(zhí)行了1毫秒，然后又切換到了A，A又執(zhí)行1毫秒。由于1毫秒的時間對于普通人來說是很難感知的，因此，從表面看上去就象A和B同時執(zhí)行一樣，但實際上A和B是交替執(zhí)行的。二、線程給我們帶來的好處 如果能合理地使用線程，將會減少開發(fā)和維護成本，甚至可以改善復雜應用程序的性能。如在GUI應用程序中，還以通過線程的異步特性來更好地處理事件；在應用 HYPERLINK / t _blank 服務器程序中可以通過建立多個線程來處理客戶端的請求。線程甚至還可以簡化虛擬機的實現(xiàn)，如 HYPERLINK / t _blank Java虛擬機（JVM）的垃圾回收器（garbage collector）通常運行在

11、一個或多個線程中。因此，使用線程將會從以下五個方面來改善我們的應用程序： 1. 充分利用CPU資源 現(xiàn)在世界上大多數(shù)計算機只有一塊CPU.因此，充分利用CPU資源顯得尤為重要。當執(zhí)行單線程程序時，由于在程序發(fā)生阻塞時CPU可能會處于空閑狀態(tài)。這將造成大量的計算資源的浪費。而在程序中使用多線程可以在某一個線程處于休眠或阻塞時，而CPU又恰好處于空閑狀態(tài)時來運行其他的線程。這樣CPU就很難有空閑的時候。因此，CPU資源就得到了充分地利用。 2.簡化編程模型 如果程序只完成一項任務，那只要寫一個單線程的程序，并且按著執(zhí)行這個任務的步驟編寫代碼即可。但要完成多項任務，如果還使用單線程的話，那就得在程序

12、中判斷每項任務是否應該執(zhí)行以及什么時候執(zhí)行。如顯示一個時鐘的時、分、秒三個指針。使用單線程就得在循環(huán)中逐一判斷這三個指針的轉動時間和角度。如果使用三個線程分另來處理這三個指針的顯示，那么對于每個線程來說就是指行一個單獨的任務。這樣有助于開發(fā)人員對程序的理解和維護。 3.簡化異步事件的處理 當一個 HYPERLINK / t _blank 服務器應用程序在接收不同的客戶端連接時最簡單地處理方法就是為每一個客戶端連接建立一個線程。然后監(jiān)聽線程仍然負責監(jiān)聽來自客戶端的請求。如果這種應用程序采用單線程來處理，當監(jiān)聽線程接收到一個客戶端請求后，開始讀取客戶端發(fā)來的數(shù)據，在讀完數(shù)據后，read方法處于阻塞

13、狀態(tài)，也就是說，這個線程將無法再監(jiān)聽客戶端請求了。而要想在單線程中處理多個客戶端請求，就必須使用非阻塞的Socket連接和異步I/O.但使用異步I/O方式比使用同步I/O更難以控制，也更容易出錯。因此，使用多線程和同步I/O可以更容易地處理類似于多請求的異步事件。 4. 使GUI更有效率 使用單線程來處理GUI事件時，必須使用循環(huán)來對隨時可能發(fā)生的GUI事件進行掃描，在循環(huán)內部除了掃描GUI事件外，還得來執(zhí)行其他的程序代碼。如果這些代碼太長，那么GUI事件就會被“凍結”，直到這些代碼被執(zhí)行完為止。 在現(xiàn)代的GUI框架（如SWING、AWT和SWT）中都使用了一個單獨的事件分派線程（event

14、dispatch thread，EDT）來對GUI事件進行掃描。當我們按下一個按鈕時，按鈕的單擊事件函數(shù)會在這個事件分派線程中被調用。由于EDT的任務只是對GUI事件進行掃描，因此，這種方式對事件的反映是非?？斓摹?5.節(jié)約成本 提高程序的執(zhí)行效率一般有三種方法： （1）增加計算機的CPU個數(shù)。 （2）為一個程序啟動多個進程 （3）在程序中使用多線程。 第一種方法是最容易做到的，但同時也是最昂貴的。這種方法不需要修改程序，從理論上說，任何程序都可以使用這種方法來提高執(zhí)行效率。第二種方法雖然不用購買新的硬件，但這種方式不容易共享數(shù)據，如果這個程序要完成的任務需要必須要共享數(shù)據的話，這種方式就不太

15、方便，而且啟動多個進程會消耗大量的系統(tǒng)資源。第三種方法恰好彌補了第一種方法的缺點，而又繼承了它們的優(yōu)點。也就是說，既不需要購買CPU，也不會因為啟太多的進程而占用大量的系統(tǒng)資源（在默認情況下，一個線程所占的內存空間要遠比一個進程所占的內存空間小得多），并且多線程可以模擬多塊CPU的運行方式，因此，使用多線程是提高程序執(zhí)行效率的最廉價的方式。三、 HYPERLINK / t _blank Java的線程模型 由于Java是純面向對象語言，因此，Java的線程模型也是面向對象的。Java通過Thread類將線程所必須的功能都封裝了起來。要想建立一個線程，必須要有一個線程執(zhí)行函數(shù)，這個線程執(zhí)行函數(shù)對

16、應Thread類的run方法。Thread類還有一個start方法，這個方法負責建立線程，相當于調用 HYPERLINK / t _blank Windows的建立線程函數(shù)CreateThread.當調用start方法后，如果線程建立成功，并自動調用Thread類的run方法。因此，任何繼承Thread的Java類都可以通過Thread類的start方法來建立線程。如果想運行自己的線程執(zhí)行函數(shù)，那就要覆蓋Thread類的run方法。 在Java的線程模型中除了Thread類，還有一個標識某個Java類是否可作為線程類的接口Runnable，這個接口只有一個抽象方法run，也就是Java線程模型

17、的線程執(zhí)行函數(shù)。因此，一個線程類的唯一標準就是這個類是否實現(xiàn)了Runnable接口的run方法，也就是說，擁有線程執(zhí)行函數(shù)的類就是線程類。從上面可以看出，在Java中建立線程有兩種方法，一種是繼承Thread類，另一種是實現(xiàn)Runnable接口，并通過Thread和實現(xiàn)Runnable的類來建立線程，其實這兩種方法從本質上說是一種方法，即都是通過Thread類來建立線程，并運行run方法的。但它們的大區(qū)別是通過繼承Thread類來建立線程，雖然在實現(xiàn)起來更容易，但由于Java不支持多繼承，因此，這個線程類如果繼承了Thread，就不能再繼承其他的類了，因此，Java線程模型提供了通過實現(xiàn)Run

18、nable接口的方法來建立線程，這樣線程類可以在必要的時候繼承和業(yè)務有關的類，而不是Thread類。用Thread類創(chuàng)建線程在 HYPERLINK / t _blank Java中創(chuàng)建線程有兩種方法：使用Thread類和使用Runnable接口。在使用Runnable接口時需要建立一個Thread實例。因此，無論是通過Thread類還是Runnable接口建立線程，都必須建立Thread類或它的子類的實例。Thread類的構造方法被重載了八次，構造方法如下：publicThread();publicThread(Runnabletarget);publicThread(Stringname);

19、publicThread(Runnabletarget,Stringname);publicThread(ThreadGroupgroup,Runnabletarget);publicThread(ThreadGroupgroup,Stringname);publicThread(ThreadGroupgroup,Runnabletarget,Stringname);publicThread(ThreadGroupgroup,Runnabletarget,Stringname,longstackSize); Runnable target 實現(xiàn)了Runnable接口的類的實例。要注意的是Thr

20、ead類也實現(xiàn)了Runnable接口，因此，從Thread類繼承的類的實例也可以作為target傳入這個構造方法。 String name 線程的名子。這個名子可以在建立Thread實例后通過Thread類的setName方法設置。如果不設置線程的名子，線程就使用默認的線程名：Thread-N，N是線程建立的順序，是一個不重復的正整數(shù)。 ThreadGroup group 當前建立的線程所屬的線程組。如果不指定線程組，所有的線程都被加到一個默認的線程組中。關于線程組的細節(jié)將在后面的章節(jié)詳細討論。 long stackSize 線程棧的大小，這個值一般是CPU頁面的整數(shù)倍。如x86的頁面大小是4

21、KB.在x86平臺下，默認的線程棧大小是12KB. 一個普通的 HYPERLINK / t _blank Java類只要從Thread類繼承，就可以成為一個線程類。并可通過Thread類的start方法來執(zhí)行線程代碼。雖然Thread類的子類可以直接實例化，但在子類中必須要覆蓋Thread類的run方法才能真正運行線程的代碼。下面的代碼給出了一個使用Thread類建立線程的例子：001packagemythread;002003publicclassThread1extendsThread004005publicvoidrun()006007System.out.println(this.ge

22、tName();008009publicstaticvoidmain(Stringargs)010011System.out.println(Thread.currentThread().getName();012Thread1thread1=newThread1();013Thread1thread2=newThread1();014thread1.start();015thread2.start();016017 上面的代碼建立了兩個線程：thread1和thread2.上述代碼中的005至008行是Thread1類的run方法。當在014和015行調用start方法時，系統(tǒng)會自動調用ru

23、n方法。在007行使用this.getName（）輸出了當前線程的名字，由于在建立線程時并未指定線程名，因此，所輸出的線程名是系統(tǒng)的默認值，也就是Thread-n的形式。在011行輸出了主線程的線程名。 上面代碼的運行結果如下：mainThread-0Thread-1 從上面的輸出結果可以看出，第一行輸出的main是主線程的名子。后面的Thread-1和Thread-2分別是thread1和thread2的輸出結果。 注意：任何一個Java程序都必須有一個主線程。一般這個主線程的名子為main.只有在程序中建立另外的線程，才能算是真正的多線程程序。也就是說，多線程程序必須擁有一個以上的線程。T

24、hread類有一個重載構造方法可以設置線程名。除了使用構造方法在建立線程時設置線程名，還可以使用Thread類的setName方法修改線程名。要想通過Thread類的構造方法來設置線程名，必須在Thread的子類中使用Thread類的public Thread（String name）構造方法，因此，必須在Thread的子類中也添加一個用于傳入線程名的構造方法。下面的代碼給出了一個設置線程名的例子：001packagemythread;002003publicclassThread2extendsThread004005privateStringwho;006007publicvoidrun(

25、)008009System.out.println(who+:+this.getName();010011publicThread2(Stringwho)012013super();014this.who=who;015016publicThread2(Stringwho,Stringname)017018super(name);019this.who=who;020021publicstaticvoidmain(Stringargs)022023Thread2thread1=newThread2(thread1,MyThread1);024Thread2thread2=newThread2(

26、thread2);025Thread2thread3=newThread2(thread3);026thread2.setName(MyThread2);027thread1.start();028thread2.start();029thread3.start();030031 在類中有兩個構造方法： 第011行：public sample2_2（String who） 這個構造方法有一個參數(shù)：who.這個參數(shù)用來標識當前建立的線程。在這個構造方法中仍然調用Thread的默認構造方法public Thread（）。 第016行：public sample2_2（String who， Str

27、ing name） 這個構造方法中的who和第一個構造方法的who的含義一樣，而name參數(shù)就是線程的名名。在這個構造方法中調用了Thread類的public Thread（String name）構造方法，也就是第018行的super（name）。 在main方法中建立了三個線程：thread1、thread2和thread3.其中thread1通過構造方法來設置線程名，thread2通過setName方法來修改線程名，thread3未設置線程名。 運行結果如下：thread1:MyThread1thread2:MyThread2thread3:Thread-2 從上面的輸出結果可以看出，t

28、hread1和thread2的線程名都已經修改了，而thread3的線程名仍然為默認值：Thread-2.thread3的線程名之所以不是Thread-1，而是Thread-2，這是因為在024行建立thread2時已經將Thread-1占用了，因此，在025行建立thread3時就將thread3的線程名設為Thread-2.然后在026行又將thread2的線程名修改為MyThread2.因此就會得到上面的輸出結果。 注意：在調用start方法前后都可以使用setName設置線程名，但在調用start方法后使用setName修改線程名，會產生不確定性，也就是說可能在run方法執(zhí)行完后才會執(zhí)

29、行setName.如果在run方法中要使用線程名，就會出現(xiàn)雖然調用了setName方法，但線程名卻未修改的現(xiàn)象。Thread類的start方法不能多次調用，如不能調用兩次thread1.start（）方法。否則會拋出一個IllegalThreadStateException異常。用Runnable接口創(chuàng)建線程實現(xiàn)Runnable接口的類必須使用Thread類的實例才能創(chuàng)建線程。通過Runnable接口創(chuàng)建線程分為兩步： 1. 將實現(xiàn)Runnable接口的類實例化。 2.建立一個Thread對象，并將第一步實例化后的對象作為參數(shù)傳入Thread類的構造方法。 最后通過Thread類的start方

30、法建立線程。 下面的代碼演示了如何使用Runnable接口來創(chuàng)建線程：packagemythread;publicclassMyRunnableimplementsRunnablepublicvoidrun()System.out.println(Thread.currentThread().getName();publicstaticvoidmain(Stringargs)MyRunnablet1=newMyRunnable();MyRunnablet2=newMyRunnable();Threadthread1=newThread(t1,MyThread1);Threadthread2=n

31、ewThread(t2);thread2.setName(MyThread2);thread1.start();thread2.start(); 上面代碼的運行結果如下：MyThread1MyThread2線程的生命周期與人有生老病死一樣，線程也同樣要經歷開始（等待）、運行、掛起和停止四種不同的狀態(tài)。這四種狀態(tài)都可以通過Thread類中的方法進行控制。下面給出了Thread類中和這四種狀態(tài)相關的方法。/開始線程 publicvoidstart(); publicvoidrun();/掛起和喚醒線程 publicvoidresume();/不建議使用 publicvoidsuspend();/不

32、建議使用publicstaticvoidsleep(longmillis); publicstaticvoidsleep(longmillis,intnanos); /終止線程 publicvoidstop();/不建議使用publicvoidinterrupt(); /得到線程狀態(tài)publicbooleanisAlive();publicbooleanisInterrupted(); publicstaticbooleaninterrupted(); /join方法publicvoidjoin()throwsInterruptedException;一、創(chuàng)建并運行線程 線程在建立后并不馬上執(zhí)

33、行run方法中的代碼，而是處于等待狀態(tài)。線程處于等待狀態(tài)時，可以通過Thread類的方法來設置線程的各種屬性，如線程的優(yōu)先級（setPriority）、線程名（setName）和線程的類型（setDaemon）等。 當調用start方法后，線程開始執(zhí)行run方法中的代碼。線程進入運行狀態(tài)。可以通過Thread類的isAlive方法來判斷線程是否處于運行狀態(tài)。當線程處于運行狀態(tài)時，isAlive返回true，當isAlive返回false時，可能線程處于等待狀態(tài)，也可能處于停止狀態(tài)。下面的代碼演示了線程的創(chuàng)建、運行和停止三個狀態(tài)之間的切換，并輸出了相應的isAlive返回值。packagecha

34、pter2;publicclassLifeCycleextendsThreadpublicvoidrun()intn=0;while(+n)1000);publicstaticvoidmain(Stringargs)throwsExceptionLifeCyclethread1=newLifeCycle();System.out.println(isAlive:+thread1.isAlive();thread1.start();System.out.println(isAlive:+thread1.isAlive();thread1.join();/等線程thread1結束后再繼續(xù)執(zhí)行Sys

35、tem.out.println(thread1已經結束!);System.out.println(isAlive:+thread1.isAlive(); 要注意一下，在上面的代碼中使用了join方法，這個方法的主要功能是保證線程的run方法完成后程序才繼續(xù)運行，這個方法將在后面的文章中介紹 上面代碼的運行結果：isAlive:falseisAlive:truethread1已經結束!isAlive:false二、掛起和喚醒線程 一但線程開始執(zhí)行run方法，就會一直到這個run方法執(zhí)行完成這個線程才退出。但在線程執(zhí)行的過程中，可以通過兩個方法使線程暫時停止執(zhí)行。這兩個方法是suspend和sle

36、ep.在使用suspend掛起線程后，可以通過resume方法喚醒線程。而使用sleep使線程休眠后，只能在設定的時間后使線程處于就緒狀態(tài)（在線程休眠結束后，線程不一定會馬上執(zhí)行，只是進入了就緒狀態(tài)，等待著系統(tǒng)進行調度）。 雖然suspend和resume可以很方便地使線程掛起和喚醒，但由于使用這兩個方法可能會造成一些不可預料的事情發(fā)生，因此，這兩個方法被標識為deprecated（抗議）標記，這表明在以后的jdk版本中這兩個方法可能被刪除，所以盡量不要使用這兩個方法來操作線程。下面的代碼演示了sleep、suspend和resume三個方法的使用。packagechapter2;public

37、classMyThreadextendsThreadclassSleepThreadextendsThreadpublicvoidrun()trysleep(2000);catch(Exceptione)publicvoidrun()while(true)System.out.println(newjava.util.Date().getTime();publicstaticvoidmain(Stringargs)throwsExceptionMyThreadthread=newMyThread();SleepThreadsleepThread=thread.newSleepThread();

38、sleepThread.start();/開始運行線程sleepThreadsleepThread.join();/使線程sleepThread延遲2秒thread.start();booleanflag=false;while(true)sleep(5000);/使主線程延遲5秒flag=!flag;if(flag)thread.suspend();elsethread.resume(); 從表面上看，使用sleep和suspend所產生的效果類似，但sleep方法并不等同于suspend.它們之間最大的一個區(qū)別是可以在一個線程中通過suspend方法來掛起另外一個線程，如上面代碼中在主線程

39、中掛起了thread線程。而sleep只對當前正在執(zhí)行的線程起作用。在上面代碼中分別使sleepThread和主線程休眠了2秒和5秒。在使用sleep時要注意，不能在一個線程中來休眠另一個線程。如main方法中使用thread.sleep（2000）方法是無法使thread線程休眠2秒的，而只能使主線程休眠2秒。 在使用sleep方法時有兩點需要注意： 1. sleep方法有兩個重載形式，其中一個重載形式不僅可以設毫秒，而且還可以設納秒（1，000，000納秒等于1毫秒）。但大多數(shù)操作系統(tǒng)平臺上的 HYPERLINK / t _blank Java虛擬機都無法精確到納秒，因此，如果對sleep

40、設置了納秒， HYPERLINK / t _blank Java虛擬機將取最接近這個值的毫秒。 2. 在使用sleep方法時必須使用throws或trycatch.因為run方法無法使用throws，所以只能使用trycatch.當在線程休眠的過程中，使用interrupt方法（這個方法將在2.3.3中討論）中斷線程時sleep會拋出一個InterruptedException異常。sleep方法的定義如下：publicstaticvoidsleep(longmillis)throwsInterruptedExceptionpublicstaticvoidsleep(longmillis,in

41、tnanos)throwsInterruptedException三、終止線程的三種方法 有三種方法可以使終止線程。 1. 使用退出標志，使線程正常退出，也就是當run方法完成后線程終止。 2. 使用stop方法強行終止線程（這個方法不推薦使用，因為stop和suspend、resume一樣，也可能發(fā)生不可預料的結果）。 3. 使用interrupt方法中斷線程。 1. 使用退出標志終止線程 當run方法執(zhí)行完后，線程就會退出。但有時run方法是永遠不會結束的。如在服務端程序中使用線程進行監(jiān)聽客戶端請求，或是其他的需要循環(huán)處理的任務。在這種情況下，一般是將這些任務放在一個循環(huán)中，如while循

42、環(huán)。如果想讓循環(huán)永遠運行下去，可以使用while（true）來處理。但要想使while循環(huán)在某一特定條件下退出，最直接的方法就是設一個boolean類型的標志，并通過設置這個標志為true或false來控制while循環(huán)是否退出。下面給出了一個利用退出標志終止線程的例子。packagechapter2;publicclassThreadFlagextendsThreadpublicvolatilebooleanexit=false;publicvoidrun()while(!exit);publicstaticvoidmain(Stringargs)throwsExceptionThreadF

43、lagthread=newThreadFlag();thread.start();sleep(5000);/主線程延遲5秒thread.exit=true;/終止線程threadthread.join();System.out.println(線程退出!); 在上面代碼中定義了一個退出標志exit，當exit為true時，while循環(huán)退出，exit的默認值為false.在定義exit時，使用了一個Java關鍵字volatile，這個關鍵字的目的是使exit同步，也就是說在同一時刻只能由一個線程來修改exit的值， 2. 使用stop方法終止線程 使用stop方法可以強行終止正在運行或掛起的線

44、程。我們可以使用如下的代碼來終止線程：thread.stop(); 雖然使用上面的代碼可以終止線程，但使用stop方法是很危險的，就象突然關閉計算機電源，而不是按正常程序關機一樣，可能會產生不可預料的結果，因此，并不推薦使用stop方法來終止線程。 3. 使用interrupt方法終止線程 使用interrupt方法來終端線程可分為兩種情況： （1）線程處于阻塞狀態(tài)，如使用了sleep方法。 （2）使用while（！isInterrupted（）來判斷線程是否被中斷。 在第一種情況下使用interrupt方法，sleep方法將拋出一個InterruptedException例外，而在第二種情況

45、下線程將直接退出。下面的代碼演示了在第一種情況下使用interrupt方法。packagechapter2;publicclassThreadInterruptextendsThreadpublicvoidrun()trysleep(50000);/延遲50秒catch(InterruptedExceptione)System.out.println(e.getMessage();publicstaticvoidmain(Stringargs)throwsExceptionThreadthread=newThreadInterrupt();thread.start();System.out.p

46、rintln(在50秒之內按任意鍵中斷線程!);System.in.read();errupt();thread.join();System.out.println(線程已經退出!); 上面代碼的運行結果如下：在50秒之內按任意鍵中斷線程! sleepinterrupted 線程已經退出! 在調用interrupt方法后， sleep方法拋出異常，然后輸出錯誤信息：sleep interrupted. 注意：在Thread類中有兩個方法可以判斷線程是否通過interrupt方法被終止。一個是靜態(tài)的方法interrupted（），一個是非靜態(tài)的方法isInterrupted（），這兩個方法的區(qū)別

47、是interrupted用來判斷當前線程是否被中斷，而isInterrupted可以用來判斷其他線程是否被中斷。因此，while （！isInterrupted（）也可以換成while（！Terrupted（）。Join()方法的使用在上面的例子中多次使用到了Thread類的join方法。我想大家可能已經猜出來join方法的功能是什么了。對，join方法的功能就是使異步執(zhí)行的線程變成同步執(zhí)行。也就是說，當調用線程實例的start方法后，這個方法會立即返回，如果在調用start方法后后需要使用一個由這個線程計算得到的值，就必須使用join方法。如果不使用join方法，就不能保證當執(zhí)行到start

48、方法后面的某條語句時，這個線程一定會執(zhí)行完。而使用join方法后，直到這個線程退出，程序才會往下執(zhí)行。下面的代碼演示了join的用法。package mythread;publicclassJoinThreadextendsThreadpublicstaticvolatileintn=0;publicvoidrun()for(inti=0;i10;i+,n+)trysleep(3);/為了使運行結果更隨機，延遲3毫秒catch(Exceptione)publicstaticvoidmain(Stringargs)throwsExceptionThreadthreads=newThread100

49、;for(inti=0;ithreads.length;i+)/建立100個線程threadsi=newJoinThread();for(inti=0;i0)for(inti=0;ithreads.length;i+)/100個線程都執(zhí)行完后繼續(xù)threadsi.join();System.out.println(n=+JoinThread.n); 在例程2-8中建立了100個線程，每個線程使靜態(tài)變量n增加10.如果在這100個線程都執(zhí)行完后輸出n，這個n值應該是1000. 1. HYPERLINK t _blank 測試1 使用如下的命令運行上面程序：java mythread.JoinTh

50、read 程序的運行結果如下：n=442 這個運行結果可能在不同的運行環(huán)境下有一些差異，但一般n不會等于1000.從上面的結果可以肯定，這100個線程并未都執(zhí)行完就將n輸出了。 2. HYPERLINK t _blank 測試2使用如下的命令運行上面的代碼：java mythread.JoinThread join 在上面的命令行中有一個參數(shù)join，其實在命令行中可以使用任何參數(shù)，只要有一個參數(shù)就可以，這里使用join，只是為了表明要使用join方法使這100個線程同步執(zhí)行。 程序的運行結果如下：n=1000 無論在什么樣的運行環(huán)境下運行上面的命令，都會得到相同的結果：n=1000.這充分說

51、明了這100個線程肯定是都執(zhí)行完了，因此，n一定會等于1000.慎重使用volatile關鍵字volatile關鍵字相信了解 HYPERLINK / t _blank Java多線程的讀者都很清楚它的作用。volatile關鍵字用于聲明簡單類型變量，如int、float、boolean等數(shù)據類型。如果這些簡單數(shù)據類型聲明為volatile，對它們的操作就會變成原子級別的。但這有一定的限制。例如，下面的例子中的n就不是原子級別的：packagemythread;publicclassJoinThreadextendsThreadpublicstatic volatile intn=0; publ

52、icvoidrun()for(inti=0;i10;i+)tryn=n+1;sleep(3);/為了使運行結果更隨機，延遲3毫秒catch(Exceptione)publicstaticvoidmain(Stringargs)throwsExceptionThreadthreads=newThread100;for(inti=0;ithreads.length;i+)/建立100個線程threadsi=newJoinThread();for(inti=0;ithreads.length;i+)/運行剛才建立的100個線程threadsi.start();for(inti=0;ithreads.

53、length;i+)/100個線程都執(zhí)行完后繼續(xù)threadsi.join();System.out.println(n=+JoinThread.n); 如果對n的操作是原子級別的，最后輸出的結果應該為n=1000，而在執(zhí)行上面積代碼時，很多時侯輸出的n都小于1000，這說明n=n+1不是原子級別的操作。原因是聲明為volatile的簡單變量如果當前值由該變量以前的值相關，那么volatile關鍵字不起作用，也就是說如下的表達式都不是原子操作：n=n+1;n+; 如果要想使這種情況變成原子操作，需要使用synchronized關鍵字，如上的代碼可以改成如下的形式：packagemythread

54、;publicclassJoinThreadextendsThreadpublicstatic intn=0;public staticsynchronizedvoidinc()n+;publicvoidrun()for(inti=0;i10;i+)tryinc();/n=n+1改成了inc();sleep(3);/為了使運行結果更隨機，延遲3毫秒catch(Exceptione)publicstaticvoidmain(Stringargs)throwsExceptionThreadthreads=newThread100;for(inti=0;ithreads.length;i+)/建立1

55、00個線程threadsi=newJoinThread();for(inti=0;ithreads.length;i+)/運行剛才建立的100個線程threadsi.start();for(inti=0;ithreads.length;i+)/100個線程都執(zhí)行完后繼續(xù)threadsi.join();System.out.println(n=+JoinThread.n); 上面的代碼將n=n+1改成了inc（），其中inc方法使用了synchronized關鍵字進行方法同步。因此，在使用volatile關鍵字時要慎重，并不是只要簡單類型變量使用volatile修飾，對這個變量的所有操作都是原子

56、操作，當變量的值由自身的上一個決定時，如n=n+1、n+等，volatile關鍵字將失效，只有當變量的值和自身上一個值無關時對該變量的操作才是原子級別的，如n = m + 1，這個就是原子級別的。所以在使用volatile關鍵時一定要謹慎，如果自己沒有把握，可以使用synchronized來代替volatile.向線程傳遞數(shù)據的三種方法在傳統(tǒng)的同步開發(fā)模式下，當我們調用一個函數(shù)時，通過這個函數(shù)的參數(shù)將數(shù)據傳入，并通過這個函數(shù)的返回值來返回最終的計算結果。但在多線程的異步開發(fā)模式下，數(shù)據的傳遞和返回和同步開發(fā)模式有很大的區(qū)別。由于線程的運行和結束是不可預料的，因此，在傳遞和返回數(shù)據時就無法象函數(shù)

57、一樣通過函數(shù)參數(shù)和return語句來返回數(shù)據。本文就以上原因介紹了幾種用于向線程傳遞數(shù)據的方法，在下一篇文章中將介紹從線程中返回數(shù)據的方法。 欲先取之，必先予之。一般在使用線程時都需要有一些初始化數(shù)據，然后線程利用這些數(shù)據進行加工處理，并返回結果。在這個過程中最先要做的就是向線程中傳遞數(shù)據。一、通過構造方法傳遞數(shù)據 在創(chuàng)建線程時，必須要建立一個Thread類的或其子類的實例。因此，我們不難想到在調用start方法之前通過線程類的構造方法將數(shù)據傳入線程。并將傳入的數(shù)據使用類變量保存起來，以便線程使用（其實就是在run方法中使用）。下面的代碼演示了如何通過構造方法來傳遞數(shù)據：package myt

58、hread;publicclassMyThread1extendsThreadprivateStringname;publicMyThread1(Stringname)=name;publicvoidrun()System.out.println(hello+name);publicstaticvoidmain(Stringargs)Threadthread=newMyThread1(world);thread.start(); 由于這種方法是在創(chuàng)建線程對象的同時傳遞數(shù)據的，因此，在線程運行之前這些數(shù)據就就已經到位了，這樣就不會造成數(shù)據在線程運行后才傳入的現(xiàn)象。如果要傳遞更復雜的數(shù)據，可以使用

59、集合、類等數(shù)據結構。使用構造方法來傳遞數(shù)據雖然比較 HYPERLINK / t _blank 安全，但如果要傳遞的數(shù)據比較多時，就會造成很多不便。由于 HYPERLINK / t _blank Java沒有默認參數(shù)，要想實現(xiàn)類似默認參數(shù)的效果，就得使用重載，這樣不但使構造方法本身過于復雜，又會使構造方法在數(shù)量上大增。因此，要想避免這種情況，就得通過類方法或類變量來傳遞數(shù)據。二、通過變量和方法傳遞數(shù)據 向對象中傳入數(shù)據一般有兩次機會，第一次機會是在建立對象時通過構造方法將數(shù)據傳入，另外一次機會就是在類中定義一系列的public的方法或變量（也可稱之為字段）。然后在建立完對象后，通過對象實例逐個賦

60、值。下面的代碼是對MyThread1類的改版，使用了一個setName方法來設置name變量：packagemythread;publicclassMyThread2implementsRunnableprivateStringname;publicvoidsetName(Stringname)=name;publicvoidrun()System.out.println(hello+name);publicstaticvoidmain(Stringargs)MyThread2myThread=newMyThread2();myThread.setName(world);Threadthrea