當(dāng)前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

多线程（初级篇）

發(fā)布時間：2023/12/2 编程问答 49 豆豆

生活随笔收集整理的這篇文章主要介紹了多线程（初级篇）小編覺得挺不錯的,現(xiàn)在分享給大家,幫大家做個參考.

線程的生命周期

線程的生命周期有五個狀態(tài)。

新建(New)：線程對象已經(jīng)創(chuàng)建，還沒有在其上調(diào)用start()方法；

就緒(Runnable)：當(dāng)線程有資格運(yùn)行，但調(diào)度程序還沒有把它選定為運(yùn)行線程時線程所處的狀態(tài)。當(dāng)start()方法調(diào)用時，線程首先進(jìn)入就緒狀態(tài)。在線程運(yùn)行之后或者從阻塞、等待或睡眠狀態(tài)回來后，也返回到可運(yùn)行狀態(tài)。

運(yùn)行(Running)：線程調(diào)度程序從可運(yùn)行池中選擇一個線程作為當(dāng)前線程時線程所處的狀態(tài)。這也是線程進(jìn)入運(yùn)行狀態(tài)的唯一一種方式。

阻塞(Blocked)：這是線程有資格運(yùn)行時它所處的狀態(tài)，線程仍舊是活的，但是當(dāng)前沒有條件運(yùn)行。換句話說，它是可運(yùn)行的，但是如果某件事件出現(xiàn)，他可能返回到可運(yùn)行狀態(tài)。

阻塞的情況分三種：

1、等待阻塞：運(yùn)行的線程執(zhí)行wait()方法，JVM會把該線程放入等待池中。

2、同步阻塞：運(yùn)行的線程在獲取對象的同步鎖時，若該同步鎖被別的線程占用，則JVM會把該線程放入鎖池中。

3、其他阻塞：運(yùn)行的線程執(zhí)行sleep()或join()方法，或者發(fā)出了I/O請求時，JVM會把該線程置為阻塞狀態(tài)。當(dāng)sleep()狀態(tài)超時、join()等待線程終止或者超時、或者I/O處理完畢時，線程重新轉(zhuǎn)入就緒狀態(tài)。

終止：當(dāng)線程的run()方法完成時就認(rèn)為它死去。這個線程對象也許是活的，但是，它已經(jīng)不是一個單獨(dú)執(zhí)行的線程。線程一旦死亡，就不能復(fù)生。如果在一個死去的線程上調(diào)用start()方法，會拋出java.lang.IllegalThreadStateException異常。

如下圖所示：

各狀態(tài)間的轉(zhuǎn)換條件如下圖所示：

線程的創(chuàng)建

有兩種方法可以創(chuàng)定義、創(chuàng)建線程：

1、繼承java.lang.Thread類

一個Thread類實(shí)例只是一個對象，像Java中的任何其他對象一樣，具有變量和方法，生死于堆上。

public class ThreadInstance extends Thread{@Overridepublic void run() {for(int i=0;i<5;i++){System.out.println(name+":"+"第"+i+"次執(zhí)行");}}public ThreadInstance(String name){this.name = name;}private String name ; }?測試類：

Thread threadA = new ThreadInstance("threadA");Thread threadB = new ThreadInstance("threadB");Thread threadC = new ThreadInstance("threadC");threadA.start();threadB.start();threadC.start();

打印結(jié)果：

threadA:第0次執(zhí)行

threadC:第0次執(zhí)行

threadB:第0次執(zhí)行

threadC:第1次執(zhí)行

threadA:第1次執(zhí)行

threadC:第2次執(zhí)行

threadB:第1次執(zhí)行

threadB:第2次執(zhí)行

threadB:第3次執(zhí)行

threadB:第4次執(zhí)行

threadC:第3次執(zhí)行

threadA:第2次執(zhí)行

threadC:第4次執(zhí)行

threadA:第3次執(zhí)行

threadA:第4次執(zhí)行

注意：由于程序運(yùn)行當(dāng)時，CPU狀態(tài)不同，線程調(diào)度器的工作狀態(tài)不同，每次的打印結(jié)果并不一致。

假如我們不調(diào)用start()方法，而是直接調(diào)用run()方法，會怎樣呢？將測試代碼作如下改動：

Thread threadA = new ThreadInstance("threadA");Thread threadB = new ThreadInstance("threadB");Thread threadC = new ThreadInstance("threadC");threadA.run();threadB.run();threadC.run();

打印結(jié)果：

threadA:第0次執(zhí)行

threadA:第1次執(zhí)行

threadA:第2次執(zhí)行

threadA:第3次執(zhí)行

threadA:第4次執(zhí)行

threadB:第0次執(zhí)行

threadB:第1次執(zhí)行

threadB:第2次執(zhí)行

threadB:第3次執(zhí)行

threadB:第4次執(zhí)行

threadC:第0次執(zhí)行

threadC:第1次執(zhí)行

threadC:第2次執(zhí)行

threadC:第3次執(zhí)行

threadC:第4次執(zhí)行

此次的打印結(jié)果是按照Thread實(shí)例的先后順序執(zhí)行的，這不是偶然的。從本質(zhì)上講，run()方法就是Thread實(shí)例的一個成員方法，如果我們直接調(diào)用，就跟調(diào)用其他成員方法一樣，不會由于線程的的調(diào)度而產(chǎn)生阻塞、執(zhí)行的狀態(tài)，而會一直執(zhí)行完畢，完畢之前后面的程序不會執(zhí)行。先執(zhí)行threadA.run()，完畢后再執(zhí)行threadB.run()，完畢后再執(zhí)行threadC.run()。所以它并不是一個多線程程序

雖然start()也是調(diào)用run()方法來執(zhí)行相關(guān)任務(wù)的，但是start()方法只是讓線程進(jìn)入可執(zhí)行狀態(tài)（就緒狀態(tài)），等待cpu分配給它時間片，并不一定會立刻執(zhí)行。這時可能有多個線程處在可執(zhí)行狀態(tài)，線程調(diào)度器輪流分配給它們時間片。所以它是一個多線程程序。

2、實(shí)現(xiàn)java.lang.Runnable接口

必須實(shí)現(xiàn)Runnable接口中的run()方法，跟Thread類中的run()方法一樣，線程執(zhí)行的任務(wù)需要寫在run()方法中。

public class RunnableInstance implements Runnable{@Overridepublic void run() {for(int i=0;i<5;i++){System.out.println(Thread.currentThread().getName()+":"+"第"+i+"次執(zhí)行");}} }

Thread的構(gòu)造方法可接受一個Runnable的實(shí)例，用Runnable的run()方法覆蓋掉Thread類的run()方法。

? ?

RunnableInstance r1 = new RunnableInstance();Thread threadA = new Thread(r1,"threadA");RunnableInstance r2 = new RunnableInstance();Thread threadB = new Thread(r2,"threadB");RunnableInstance r3 = new RunnableInstance();Thread threadC = new Thread(r3,"threadC");threadA.start();threadB.start();threadC.start();

打印結(jié)果：

threadA:第0次執(zhí)行

threadB:第0次執(zhí)行

threadA:第1次執(zhí)行

threadB:第1次執(zhí)行

threadA:第2次執(zhí)行

threadB:第2次執(zhí)行

threadC:第0次執(zhí)行

threadC:第1次執(zhí)行

threadC:第2次執(zhí)行

threadC:第3次執(zhí)行

threadC:第4次執(zhí)行

threadA:第3次執(zhí)行

threadA:第4次執(zhí)行

threadB:第3次執(zhí)行

threadB:第4次執(zhí)行

執(zhí)行效果與Thread的效果類似。

在測試程序中，每個Thread持有一個Runnable實(shí)例，互不干擾。試想，如果讓Thread共享一個Runnable實(shí)例，會發(fā)生什么情況呢？

RunnableInstance r1 = new RunnableInstance();Thread threadA = new Thread(r1,"threadA");//RunnableInstance r2 = new RunnableInstance();Thread threadB = new Thread(r1,"threadB");//RunnableInstance r3 = new RunnableInstance();Thread threadC = new Thread(r1,"threadC");threadA.start();threadB.start();threadC.start();

打印結(jié)果：

threadA:第0次執(zhí)行

threadA:第1次執(zhí)行

threadC:第0次執(zhí)行

threadB:第0次執(zhí)行

threadC:第1次執(zhí)行

threadA:第2次執(zhí)行

threadC:第2次執(zhí)行

threadB:第1次執(zhí)行

threadC:第3次執(zhí)行

threadA:第3次執(zhí)行

threadC:第4次執(zhí)行

threadB:第2次執(zhí)行

threadB:第3次執(zhí)行

threadB:第4次執(zhí)行

threadA:第4次執(zhí)行

可見，與原來的測試結(jié)果類似，并沒有特別的地方。

這是因?yàn)闆]有出現(xiàn)多線程競爭同一個資源的情況。將Runnable接口改動如下：

public class RunnableInstance implements Runnable{@Overridepublic void run() {while(count > 0){count = count-10;System.out.println(Thread.currentThread().getName()+"取出10元，余額："+count);}}private int count = 100;}
在進(jìn)行測試，打印結(jié)果如下：

threadA取出10元，余額：80

threadC取出10元，余額：70

threadB取出10元，余額：80

threadB取出10元，余額：40

threadC取出10元，余額：50

threadC取出10元，余額：20

threadC取出10元，余額：10

threadC取出10元，余額：0

threadA取出10元，余額：60

threadB取出10元，余額：30

結(jié)果顯然不正常。

這是因?yàn)槎鄠€線程同時對同一實(shí)例中的統(tǒng)一數(shù)據(jù)進(jìn)行了讀取操作造成的。為了避免這種情況，使共享數(shù)據(jù)在同一時刻只能有一個線程進(jìn)行讀取，這就是線程的同步控制。

3、補(bǔ)充

1、一個運(yùn)行中的線程總是有名字的，名字有兩個來源，一個是虛擬機(jī)自己給的名字，一個是你自己的定的名字。在沒有指定線程名字的情況下，虛擬機(jī)總會為線程指定名字，并且主線程的名字總是mian，非主線程的名字不確定。

2、線程都可以設(shè)置名字，也可以獲取線程的名字，連主線程也不例外。

3、獲取當(dāng)前線程的對象的方法是：Thread.currentThread()；

4、在上面的代碼中，只能保證：每個線程都將啟動，每個線程都將運(yùn)行直到完成。一系列線程以某種順序啟動并不意味著將按該順序執(zhí)行。對于任何一組啟動的線程來說，調(diào)度程序不能保證其執(zhí)行次序，持續(xù)時間也無法保證。

5、當(dāng)線程目標(biāo)run()方法結(jié)束時該線程完成。

6、一旦線程啟動，它就永遠(yuǎn)不能再重新啟動。只有一個新的線程可以被啟動，并且只能一次。一個可運(yùn)行的線程或死線程可以被重新啟動。

7、線程的調(diào)度是JVM的一部分，在一個CPU的機(jī)器上上，實(shí)際上一次只能運(yùn)行一個線程。一次只有一個線程棧執(zhí)行。JVM線程調(diào)度程序決定實(shí)際運(yùn)行哪個處于可運(yùn)行狀態(tài)的線程。眾多可運(yùn)行線程中的某一個會被選中做為當(dāng)前線程。可運(yùn)行線程被選擇運(yùn)行的順序是沒有保障的。

8、盡管通常采用隊(duì)列形式，但這是沒有保障的。隊(duì)列形式是指當(dāng)一個線程完成“一輪”時，它移到可運(yùn)行隊(duì)列的尾部等待，直到它最終排隊(duì)到該隊(duì)列的前端為止，它才能被再次選中。事實(shí)上，我們把它稱為可運(yùn)行池而不是一個可運(yùn)行隊(duì)列，目的是幫助認(rèn)識線程并不都是以某種有保障的順序排列成個一個隊(duì)列的事實(shí)。

9、盡管我們沒有無法控制線程調(diào)度程序，但可以通過別的方式來影響線程調(diào)度的方式，比如設(shè)置優(yōu)先級，以及調(diào)用Thread.sleep()，wait()，yield()等方法。

線程的狀態(tài)裝換

sleep()方法

Thread.sleep(long millis)和Thread.sleep(long millis,int nanos)靜態(tài)方法強(qiáng)制當(dāng)前正在執(zhí)行的線程休眠（暫停執(zhí)行），以“減慢線程”。當(dāng)線程睡眠時，它入睡在某個地方，在蘇醒之前不會返回到可運(yùn)行狀態(tài)。當(dāng)睡眠時間到期，則返回到可運(yùn)行狀態(tài)。但它并不釋放對象鎖。也就是說如果有synchronized同步快，其他線程仍然不能訪問共享數(shù)據(jù)。

例如，在前面的例子中，模擬一個耗時的操作，以減慢線程的執(zhí)行。可以這么寫：

public class ThreadInstance extends Thread{private String name ;@Overridepublic void run() {for(int i=1;i<9;i++){if(i%3 == 0){try {System.out.println(name+"睡眠0.02秒");Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(name+":"+"第"+i+"次執(zhí)行");}}public ThreadInstance(String name){this.name = name;}public static void main(String[] args) {Thread threadA = new ThreadInstance("threadA");Thread threadB = new ThreadInstance("threadB");Thread threadC = new ThreadInstance("threadC");threadA.start();threadB.start();threadC.start();} }

打印結(jié)果：

threadA:第1次執(zhí)行

threadC:第1次執(zhí)行

threadB:第1次執(zhí)行

threadC:第2次執(zhí)行

threadA:第2次執(zhí)行

threadC睡眠2秒

threadB:第2次執(zhí)行

threadA睡眠2秒

threadB睡眠2秒

threadC:第3次執(zhí)行

threadC:第4次執(zhí)行

threadC:第5次執(zhí)行

threadC睡眠2秒

threadA:第3次執(zhí)行

threadB:第3次執(zhí)行

threadA:第4次執(zhí)行

threadB:第4次執(zhí)行

threadA:第5次執(zhí)行

threadB:第5次執(zhí)行

threadA睡眠2秒

threadB睡眠2秒

threadC:第6次執(zhí)行

threadC:第7次執(zhí)行

threadC:第8次執(zhí)行

threadA:第6次執(zhí)行

threadA:第7次執(zhí)行

threadA:第8次執(zhí)行

threadB:第6次執(zhí)行

threadB:第7次執(zhí)行

threadB:第8次執(zhí)行

為了讓其他線程有機(jī)會執(zhí)行，將Thread.sleep()的調(diào)用放線程run()之內(nèi)。這樣才能保證該線程執(zhí)行過程中會睡眠。

1、線程睡眠是幫助所有線程獲得運(yùn)行機(jī)會的最好方法。

2、線程睡眠到期自動蘇醒，并返回到就緒狀態(tài)，不是運(yùn)行狀態(tài)。sleep()中指定的時間是線程不會運(yùn)行的最短時間。因此，sleep()方法不能保證該線程睡眠到期后就開始執(zhí)行。

3、sleep()是靜態(tài)方法，只能控制當(dāng)前正在運(yùn)行的線程。

yield()方法

線程的讓步是通過Thread.yield()來實(shí)現(xiàn)的。yield()方法的作用是：暫停當(dāng)前正在執(zhí)行的線程對象，并執(zhí)行其他線程。

要理解yield()，必須了解線程的優(yōu)先級的概念。線程總是存在優(yōu)先級，優(yōu)先級范圍在1~10之間。JVM線程調(diào)度程序是基于優(yōu)先級的搶先調(diào)度機(jī)制。在大多數(shù)情況下，當(dāng)前運(yùn)行的線程優(yōu)先級將大于或等于線程池中任何線程的優(yōu)先級。但這僅僅是大多數(shù)情況。

注意：當(dāng)設(shè)計(jì)多線程應(yīng)用程序的時候，一定不要依賴于線程的優(yōu)先級。因?yàn)?strong>線程調(diào)度優(yōu)先級操作是沒有保障的，優(yōu)先級越高只能代表它獲取cpu資源的概率比較大。只能把線程優(yōu)先級作用作為一種提高程序效率的方法，但是要保證程序不依賴這種操作。

當(dāng)線程池中線程都具有相同的優(yōu)先級，調(diào)度程序的JVM實(shí)現(xiàn)自由選擇它喜歡的線程。這時候調(diào)度程序的操作有兩種可能：一是選擇一個線程運(yùn)行，直到它阻塞或者運(yùn)行完成為止。二是時間分片，為池內(nèi)的每個線程提供均等的運(yùn)行機(jī)會。

設(shè)置線程的優(yōu)先級：線程默認(rèn)的優(yōu)先級是創(chuàng)建它的執(zhí)行線程的優(yōu)先級。可以通過setPriority(int newPriority)更改線程的優(yōu)先級。例如：

Thread t = new MyThread();t.setPriority(8);t.start();

線程優(yōu)先級為1~10之間的正整數(shù)，JVM從不會改變一個線程的優(yōu)先級。然而，1~10之間的值是沒有保證的。一些JVM可能不能識別10個不同的值，而將這些優(yōu)先級進(jìn)行每兩個或多個合并，變成少于10個的優(yōu)先級，則兩個或多個優(yōu)先級的線程可能被映射為一個優(yōu)先級。

線程默認(rèn)優(yōu)先級是5，Thread類中有三個常量，定義線程優(yōu)先級范圍：

static int MAX_PRIORITY

????????? 線程可以具有的最高優(yōu)先級。

static int MIN_PRIORITY

????????? 線程可以具有的最低優(yōu)先級。

static int NORM_PRIORITY

????????? 分配給線程的默認(rèn)優(yōu)先級。

yield()應(yīng)該做的是讓當(dāng)前運(yùn)行線程回到可運(yùn)行狀態(tài)，以允許具有相同優(yōu)先級的其他線程獲得運(yùn)行機(jī)會。因此，使用yield()的目的是讓相同優(yōu)先級的線程之間能適當(dāng)?shù)妮嗈D(zhuǎn)執(zhí)行。但是，實(shí)際中無法保證yield()達(dá)到讓步目的，因?yàn)樽尣降木€程還有可能被線程調(diào)度程序再次選中。

yield()從未導(dǎo)致線程轉(zhuǎn)到等待/睡眠/阻塞狀態(tài)。在大多數(shù)情況下，yield()將導(dǎo)致線程從運(yùn)行狀態(tài)轉(zhuǎn)到就緒狀態(tài)，但有可能沒有效果。

join()方法

join() 方法主要是讓調(diào)用該方法的thread完成run方法里面的東西后，再執(zhí)行join()方法后面的代碼。示例：

public class ThreadInstance extends Thread{public static int count = 5 ;@Overridepublic void run() {for(int i=0;i<5;i++){count--;System.out.print(count+",");}}public static void main(String[] args) {Thread threadA = new ThreadInstance();threadA.start();System.out.println(ThreadInstance.count);} }
打印結(jié)果如下：

4,3,2,1,0,

就是說，System.out.println(ThreadInstance.count)這條語句打印出的結(jié)果為“5”，而不是“0”。

這是因?yàn)樵谏厦娴某绦蛑写嬖趦蓚€線程，一個是主線程main，一個是子線程threadA。兩個線程并發(fā)執(zhí)行，threadA.start()只是讓threadA進(jìn)入就緒狀態(tài)，并不一定會立即執(zhí)行。同時main主線程不會等待threadA執(zhí)行完畢，而是執(zhí)行后面的語句，此時靜態(tài)變量count還沒有被threadA改變，打印出的結(jié)果是“5”。

如果想保證threadA執(zhí)行完畢之后再執(zhí)行后面的語句，就需要用到j(luò)oin()方法了。將程序修改如下：

public class ThreadInstance extends Thread{public static int count = 5 ;@Overridepublic void run() {for(int i=0;i<5;i++){count--;System.out.print(count+",");}System.out.println();}public static void main(String[] args)throws InterruptedException {Thread threadA = new ThreadInstance();threadA.start();threadA.join();System.out.println(ThreadInstance.count);} }

打印結(jié)果如下：

4,3,2,1,0,

可見，join()方法保證了threadA執(zhí)行完畢之后采取執(zhí)行后面的語句。

在上例中，main線程是執(zhí)行threadA的線程，join從字面上理解是“加入”的意思，就是表示把該線程加入到調(diào)用該線程的線程，保證其執(zhí)行完畢再進(jìn)行下一步的工作。

另外，join()方法還有帶超時限制的重載版本。例如threadA.join(5000);則讓線程等待5000毫秒，如果超過這個時間，則停止等待，變?yōu)榭蛇\(yùn)行狀態(tài)。

interrupt()方法

首先來說說java中的中斷機(jī)制，Java中斷機(jī)制是一種協(xié)作機(jī)制，也就是說通過中斷并不能直接終止另一個線程，而需要被中斷的線程自己處理中斷。當(dāng)調(diào)用interrupt()方法的時候，只是設(shè)置了要中斷線程的中斷狀態(tài)，而此時被中斷的線程的可以通過非靜態(tài)方法isInterrupted()或者是靜態(tài)方法interrupted()方法判斷當(dāng)前線程的中斷狀態(tài)是否標(biāo)志為中斷。

來看一個例子：

class ATask implements Runnable{ private double d = 0.0; public void run() { //死循環(huán)執(zhí)行打印"I am running!" 和做消耗時間的浮點(diǎn)計(jì)算 while (true) { System.out.println("I am running!"); for (int i = 0; i < 900000; i++){ d = d + (Math.PI + Math.E) / d; } } } } public class InterruptTaskTest { public static void main(String[] args)throws Exception{ //將任務(wù)交給一個線程執(zhí)行 Thread t = new Thread(new ATask()); t.start(); //運(yùn)行一斷時間中斷線程 Thread.sleep(100); System.out.println("****************************"); System.out.println("InterruptedThread!"); System.out.println("****************************"); t.interrupt(); } }

運(yùn)行這個程序，我們發(fā)現(xiàn)調(diào)用interrupt()后，程序仍在運(yùn)行，如果不強(qiáng)制結(jié)束，程序?qū)⒁恢边\(yùn)行下去，如下所示:

I am running!?

****************************?

InterruptedThread!?

****************************?

I am running!?

....?

interrupt()只是改變中斷狀態(tài)而已。interrupt()不會中斷一個正在運(yùn)行的線程。這一方法實(shí)際上完成的是，給受阻塞的線程拋出一個中斷信號，

這樣受阻線程就得以退出阻塞的狀態(tài)。更確切地說，如果線程被Object.wait, Thread.join和Thread.sleep三種方法之一阻塞，那么，它將接收到一個中斷異常（InterruptedException），從而提早地終結(jié)被阻塞狀態(tài)。

如果線程沒有被阻塞，這時調(diào)用interrupt()將不起作用；否則，線程就將得到InterruptedException異常（該線程必須事先預(yù)備好處理此狀況），接著逃離阻塞狀態(tài)。

離開線程有兩種常用的方法：

拋出InterruptedException和用Thread.interrupted()檢查是否發(fā)生中斷，下面分別看一下這兩種方法：

1、在阻塞操作時如Thread.sleep()時被中斷會拋出InterruptedException(注意，進(jìn)行不能中斷的IO操作而阻塞和要獲得對象的鎖調(diào)用對象的synchronized方法而阻塞時不會拋出InterruptedException)

class ATask implements Runnable{ private double d = 0.0; public void run() { //死循環(huán)執(zhí)行打印"I am running!" 和做消耗時間的浮點(diǎn)計(jì)算 try { while (true) { System.out.println("I am running!"); for (int i = 0; i < 900000;i++) { d = d + (Math.PI + Math.E) / d; } //休眠一斷時間，在休眠的過程中接收到中斷信號，會拋出InterruptedException Thread.sleep(50); } } catch (InterruptedException e) { System.out.println("ATask.run() interrupted!"); } } }

打印結(jié)果：

I am running!?

****************************?

InterruptedThread!?

****************************?

ATask.run() interrupted!

2、Thread.interrupted()檢查是否發(fā)生中斷。Thread.interrupted()能告訴你線程是否發(fā)生中斷，并將清除中斷狀態(tài)標(biāo)記，所以程序不會兩次通知你線程發(fā)生了中斷

class ATask implements Runnable{ private double d = 0.0; public void run() { //檢查程序是否發(fā)生中斷 while (!Thread.interrupted()) { System.out.println("I am running!"); for (int i = 0; i < 900000; i++){ d = d + (Math.PI + Math.E) /d; } } System.out.println("ATask.run()interrupted!"); } }

打印結(jié)果：

I am running!?

****************************?

InterruptedThread!?

****************************?

ATask.run()interrupted!

但這其實(shí)是在sleep,wait,join這些方法內(nèi)部會不斷檢查中斷狀態(tài)的值，而自己拋出的InterruptedException。

當(dāng)線程A終于執(zhí)行到wait(),sleep(),join()時，才馬上會拋出InterruptedException。

若沒有調(diào)用sleep(),wait(),join()這些方法,即沒有在線程里自己檢查中斷狀態(tài)自己拋出InterruptedException的話，那InterruptedException是不會被拋出來的。

我們可結(jié)合使用兩種方法來達(dá)到可以通過interrupt()中斷線程。請看下面例子：

class ATask implements Runnable{ private double d = 0.0; public void run() { try { //檢查程序是否發(fā)生中斷 while (!Thread.interrupted()) { System.out.println("I am running!"); Thread.sleep(20); System.out.println("Calculating"); for (int i = 0; i < 900000; i++){ d = d + (Math.PI + Math.E) / d; } } } catch (InterruptedException e) { System.out.println("Exiting byException"); } System.out.println("ATask.run()interrupted!"); } }

還有一點(diǎn)需要特別注意，Thread.stop()也是讓線程中斷的靜態(tài)方法，與Thread .interrupt() 最大的區(qū)別在于：interrupt（）方法是設(shè)置線程的中斷狀態(tài)，讓用戶自己選擇時間地點(diǎn)去結(jié)束線程；而stop（）方法會在代碼的運(yùn)行處直接拋出一個ThreadDeath錯誤，這是一個java.lang.Error的子類。所以直接使用stop()方法就有可能造成對象的不一致性。

Thread.stop()不推薦使用。

其他方法

除了以上方法，Thread類中還有JDK舊版本的遺留方法。

suspend() /resume()方法對：suspend()是線程掛起，直到調(diào)用resume()方法使之恢復(fù)到就緒狀態(tài)。

因?yàn)檫@對方法具有死鎖傾向，JDK只是為了兼容舊版本而保留，不推薦使用。

stop()方法：無論該線程在做些什么，它所代表的線程都被迫異常停止，并拋出一個新創(chuàng)建的 ThreadDeath 對象，作為異常。

該方法具有固有的不安全性。JDK只是為了兼容舊版本而保留，不推薦使用。

補(bǔ)充

到目前位置，介紹了線程離開運(yùn)行狀態(tài)的3種方法：

1、調(diào)用Thread.sleep()：使當(dāng)前線程睡眠至少多少毫秒（盡管它可能在指定的時間之前被中斷）。

2、調(diào)用Thread.yield()：不能保障太多事情，盡管通常它會讓當(dāng)前運(yùn)行線程回到可運(yùn)行性狀態(tài)，使得有相同優(yōu)先級的線程有機(jī)會執(zhí)行。

3、調(diào)用join()方法：保證當(dāng)前線程停止執(zhí)行，直到該線程所加入的線程完成為止。然而，如果它加入的線程沒有存活，則當(dāng)前線程不需要停止。

4、這里要明確的一點(diǎn)，不管程序員怎么編寫調(diào)度，只能最大限度的影響線程執(zhí)行的次序，而不能做到精準(zhǔn)控制。

除了以上三種方式外，還有下面幾種特殊情況可能使線程離開運(yùn)行狀態(tài)：

1、線程的run()方法完成。

2、在對象上調(diào)用wait()方法（不是在線程上調(diào)用）。

3、線程不能在對象上獲得鎖定，它正試圖運(yùn)行該對象的方法代碼。

4、線程調(diào)度程序可以決定將當(dāng)前運(yùn)行狀態(tài)移動到可運(yùn)行狀態(tài)，以便讓另一個線程獲得運(yùn)行機(jī)會，而不需要任何理由。

線程的同步

由于同一進(jìn)程的多個線程共享同一片存儲空間，在帶來方便的同時，也帶來了訪問沖突這個嚴(yán)重的問題。Java語言提供了專門機(jī)制以解決這種沖突，有效避免了同一個數(shù)據(jù)對象被多個線程同時訪問。

在具體的Java代碼中需要完成一下兩個操作：

1、把競爭訪問的資源變量標(biāo)識為private；

2、同步哪些修改變量的代碼，使用synchronized關(guān)鍵字同步方法或代碼。

當(dāng)然這不是唯一控制并發(fā)安全的途徑。

同步

Java中每個對象都有一個內(nèi)置鎖。

當(dāng)程序運(yùn)行到非靜態(tài)的synchronized同步方法上時，自動獲得與正在執(zhí)行代碼類的當(dāng)前實(shí)例（this實(shí)例）有關(guān)的鎖。獲得一個對象的鎖也稱為獲取鎖、鎖定對象、在對象上鎖定或在對象上同步。

當(dāng)程序運(yùn)行到synchronized同步方法或代碼塊時才該對象鎖才起作用。

一個對象只有一個鎖。所以，如果一個線程獲得該鎖，就沒有其他線程可以獲得鎖，直到第一個線程釋放（或返回）鎖。這也意味著任何其他線程都不能進(jìn)入該對象上的synchronized方法或代碼塊，直到該鎖被釋放。

釋放鎖是指持鎖線程退出了synchronized同步方法或代碼塊。

在使用同步代碼塊時候，應(yīng)該指定在哪個對象上同步，也就是說要獲取哪個對象的鎖。例如：

? ??

public int fix(int y) {synchronized (this) {x = x - y;}return x;}

當(dāng)然，同步方法也可以改寫為非同步方法，但功能完全一樣的，例如： ??

public synchronized int getX() {return x++;}

與

public int getX() {synchronized (this) {return x++;}}
效果是完全一樣的。

要同步靜態(tài)方法，需要一個用于整個類對象的鎖，這個對象是就是這個類（XXX.class)。顯而易見，因?yàn)殪o態(tài)方法、靜態(tài)變量都是與類綁定的，而不是與某個特定的對象綁定。

?例如：

public static synchronized int setName(String name){Xxx.name = name;}

等價(jià)于

public static int setName(String name){synchronized(Xxx.class){Xxx.name = name;} }?

如果線程試圖進(jìn)入同步方法，而其鎖已經(jīng)被占用，則線程在該對象上被阻塞。實(shí)質(zhì)上，線程進(jìn)入該對象的的一種鎖池中，必須在那里等待，直到其鎖被釋放，該線程再次變?yōu)榭蛇\(yùn)行或運(yùn)行為止。

當(dāng)考慮阻塞時，一定要注意哪個對象正被用于鎖定：

1、調(diào)用同一個對象中非靜態(tài)同步方法的線程將彼此阻塞。如果是不同對象，則每個線程有自己的對象的鎖，線程間彼此互不干預(yù)。

2、調(diào)用同一個類中的靜態(tài)同步方法的線程將彼此阻塞，它們都是鎖定在相同的Class對象上。

3、靜態(tài)同步方法和非靜態(tài)同步方法將永遠(yuǎn)不會彼此阻塞，因?yàn)殪o態(tài)方法鎖定在Class對象上，非靜態(tài)方法鎖定在該類的對象上。

4、對于同步代碼塊，要看清楚什么對象已經(jīng)用于鎖定（synchronized后面括號的內(nèi)容）。在同一個對象上進(jìn)行同步的線程將彼此阻塞，在不同對象上鎖定的線程將永遠(yuǎn)不會彼此阻塞。

死鎖

死鎖對Java程序來說，是很復(fù)雜的，也很難發(fā)現(xiàn)問題。當(dāng)兩個線程被阻塞，每個線程在等待另一個線程時就發(fā)生死鎖。

來看一個實(shí)例：

public class DeadlockRisk {private static class Resource {public int value;}private Resource resourceA =new Resource();private Resource resourceB =new Resource();public int read() {synchronized (resourceA) {synchronized (resourceB) {return resourceB.value +resourceA.value;}}}public void write(int a,int b) {synchronized (resourceB) {synchronized (resourceA) {resourceA.value = a;resourceB.value = b;}}} }

假設(shè)read()方法由一個線程啟動，write()方法由另外一個線程啟動。讀線程將擁有resourceA鎖，寫線程將擁有resourceB鎖，兩者都堅(jiān)持等待的話就出現(xiàn)死鎖。

實(shí)際上，上面這個例子發(fā)生死鎖的概率很小。因?yàn)樵诖a內(nèi)的某個點(diǎn)，CPU必須從讀線程切換到寫線程，所以，死鎖基本上不能發(fā)生。

就算我們費(fèi)盡心機(jī)去寫一個故意死鎖的程序，也不見會發(fā)生死鎖。但是，無論代碼中發(fā)生死鎖的概率有多小，一旦發(fā)生死鎖，程序就死掉。

volatile關(guān)鍵字

在Java內(nèi)存模型中，有main memory，每個線程也有自己的memory (例如寄存器)。為了性能，一個線程會在自己的memory中保持要訪問的變量的副本。這樣就會出現(xiàn)同一個變量在某個瞬間，在一個線程的memory中的值可能與另外一個線程memory中的值，或者main memory中的值不一致的情況。

一個變量聲明為volatile，就意味著這個變量是隨時會被其他線程修改的，因此不能將它c(diǎn)ache在線程memory中

當(dāng)我們使用volatile關(guān)鍵字去修飾變量的時候，所有線程都會直接讀取該變量并且不緩存它。這就確保了線程讀取到的變量是同內(nèi)存中是一致的。

volatile可以用在任何變量前面，但不能用于final變量前面，因?yàn)閒inal型的變量是禁止修改的。也不存在線程安全的問題。

Java 語言中的 volatile變量可以被看作是一種“程度較輕的 synchronized”；與 synchronized 塊相比，volatile 變量所需的編碼較少，并且運(yùn)行時開銷也較少，但是它所能實(shí)現(xiàn)的功能也僅是 synchronized 的一部分。

之所以要單獨(dú)提出volatile這個不常用的關(guān)鍵字原因是這個關(guān)鍵字在高性能的多線程程序中也有很重要的用途，只是這個關(guān)鍵字用不好會出很多問題。

只能在有限的一些情形下使用volatile 變量替代鎖。要使 volatile 變量提供理想的線程安全，必須同時滿足下面兩個條件：

1、對變量的寫操作不依賴于當(dāng)前值。

2、該變量沒有包含在具有其他變量的不變式中。

實(shí)際上，這些條件表明，可以被寫入volatile 變量的這些有效值獨(dú)立于任何程序的狀態(tài)，包括變量的當(dāng)前狀態(tài)。

第一個條件的限制使 volatile 變量不能用作線程安全計(jì)數(shù)器。雖然增量操作（x++）看上去類似一個單獨(dú)操作，實(shí)際上它是一個由讀取－修改－寫入操作序列組成的組合操作，必須以原子方式執(zhí)行，而volatile 不能提供必須的原子特性。實(shí)現(xiàn)正確的操作需要使 x的值在操作期間保持不變，而 volatile 變量無法實(shí)現(xiàn)這點(diǎn)。（然而，如果將值調(diào)整為只從單個線程寫入，那么可以忽略第一個條件。）

大多數(shù)編程情形都會與這兩個條件的其中之一沖突，使得 volatile 變量不能像 synchronized 那樣普遍適用于實(shí)現(xiàn)線程安全。

比如做了一個i++操作，計(jì)算機(jī)內(nèi)部做了三次處理：讀取－修改－寫入。

同樣，對于一個long型數(shù)據(jù)，做了個賦值操作，在32位系統(tǒng)下需要經(jīng)過兩步才能完成，先修改低32位，然后修改高32位。

假想一下，當(dāng)將以上的操作放到一個多線程環(huán)境下操作時候，有可能出現(xiàn)的問題，是這些步驟執(zhí)行了一部分，而另外一個線程就已經(jīng)引用了變量值，這樣就導(dǎo)致了讀取臟數(shù)據(jù)的問題。

用volatile修飾的變量，線程在每次使用變量的時候，都會讀取變量修改后的最的值。volatile很容易被誤用，用來進(jìn)行原子性操作。

下面看一個例子，我們實(shí)現(xiàn)一個計(jì)數(shù)器，每次線程啟動的時候，會調(diào)用計(jì)數(shù)器inc方法，對計(jì)數(shù)器進(jìn)行加一。

public class Counter {public static int count = 0;public static void inc() {//這里延遲1毫秒，使得結(jié)果明顯try {Thread.sleep(1);} catch (InterruptedException e) {}count++;}public static void main(String[] args) {//同時啟動1000個線程，去進(jìn)行i++計(jì)算，看看實(shí)際結(jié)果for (int i = 0; i < 1000; i++) {new Thread(new Runnable() {@Overridepublic void run() {Counter.inc();}}).start();}//這里每次運(yùn)行的值都有可能不同,可能為1000System.out.println("運(yùn)行結(jié)果:Counter.count="+ Counter.count);} }?

運(yùn)行結(jié)果:Counter.count=995

實(shí)際運(yùn)算結(jié)果每次可能都不一樣，本機(jī)的結(jié)果為：運(yùn)行結(jié)果:Counter.count=995，可以看出，在多線程的環(huán)境下，Counter.count并沒有期望結(jié)果是1000

很多人以為，這個是多線程并發(fā)問題，只需要在變量count之前加上volatile就可以避免這個問題，那我們在修改代碼看看，看看結(jié)果是不是符合我們的期望

public class Counter {public volatile static int count = 0;public static void inc() {//這里延遲1毫秒，使得結(jié)果明顯try {Thread.sleep(1);} catch (InterruptedException e) {}count++;}public static void main(String[] args) {//同時啟動1000個線程，去進(jìn)行i++計(jì)算，看看實(shí)際結(jié)果for (int i = 0; i < 1000; i++) {new Thread(new Runnable() {@Overridepublic void run() {Counter.inc();}}).start();}//這里每次運(yùn)行的值都有可能不同,可能為1000System.out.println("運(yùn)行結(jié)果:Counter.count="+ Counter.count);} }
運(yùn)行結(jié)果:Counter.count=992

運(yùn)行結(jié)果還是沒有我們期望的1000，下面我們分析一下原因。

jvm在運(yùn)行時刻內(nèi)存的分配，其中有一個內(nèi)存區(qū)域是jvm虛擬機(jī)棧，每一個線程運(yùn)行時都有一個線程棧，

線程棧保存了線程運(yùn)行時候變量值信息。當(dāng)線程訪問某一個對象時候值的時候，首先通過對象的引用找到對應(yīng)在堆內(nèi)存的變量的值，然后把堆內(nèi)存變量的具體值load到線程本地內(nèi)存中，建立一個變量副本，之后線程就不再和對象在堆內(nèi)存變量值有任何關(guān)系，而是直接修改副本變量的值，在修改完之后的某一個時刻（線程退出之前），自動把線程變量副本的值回寫到對象在堆中變量。這樣在堆中的對象的值就產(chǎn)生變化了。下面一幅圖描述這些交互

read and load 從主存復(fù)制變量到當(dāng)前工作內(nèi)存

use andassign? 執(zhí)行代碼，改變共享變量值

store and write 用工作內(nèi)存數(shù)據(jù)刷新主存相關(guān)內(nèi)容

其中use and assign 可以多次出現(xiàn)

但是這一些操作并不是原子性，也就是在read load之后，如果主內(nèi)存count變量發(fā)生修改之后，線程工作內(nèi)存中的值由于已經(jīng)加載，不會產(chǎn)生對應(yīng)的變化，所以計(jì)算出來的結(jié)果會和預(yù)期不一樣

對于volatile修飾的變量，jvm虛擬機(jī)只是保證從主內(nèi)存加載到線程工作內(nèi)存的值是最新的。

例如假如線程1，線程2 在進(jìn)行read,load 操作中，發(fā)現(xiàn)主內(nèi)存中count的值都是5，那么都會加載這個最新的值。

在線程1堆count進(jìn)行修改之后，會write到主內(nèi)存中，主內(nèi)存中的count變量就會變?yōu)?。

線程2由于已經(jīng)進(jìn)行read,load操作，在進(jìn)行運(yùn)算之后，也會更新主內(nèi)存count的變量值為6。

導(dǎo)致兩個線程盡管使用了volatile關(guān)鍵字，還是會存在并發(fā)的情況。

總之，個人建議，volatile能不用就不用，非高手不能駕馭。

補(bǔ)充

1、對于同步，要時刻清醒在哪個對象上同步，這是關(guān)鍵。

2、每個對象只有一個鎖；當(dāng)提到同步時，應(yīng)該清楚在什么上同步，也就是說在哪個對象上同步。

3、不必同步類中所有的方法，類可以同時擁有同步和非同步方法。

4、如果兩個線程要執(zhí)行一個類中的synchronized方法，并且兩個線程使用相同的實(shí)例來調(diào)用方法，那么一次只能有一個線程能夠執(zhí)行方法，另一個需要等待，直到鎖被釋放。也就是說：如果一個線程在對象上獲得一個鎖，就沒有任何其他線程可以進(jìn)入（該對象的）類中的任何一個同步方法。

5、如果線程擁有同步和非同步方法，則非同步方法可以被多個線程自由訪問而不受鎖的限制。

6、線程睡眠時，它所持的任何鎖都不會釋放。

7、線程可以獲得多個鎖。比如，在一個對象的同步方法里面調(diào)用另外一個對象的同步方法，則獲取了兩個對象的同步鎖。

8、同步損害并發(fā)性，應(yīng)該盡可能縮小同步范圍。同步不但可以同步整個方法，還可以同步方法中一部分代碼塊。

9、synchronized關(guān)鍵字是不能繼承的，也就是說，基類的方法synchronizedf(){} 在繼承類中并不自動是synchronized f(){}，而是變成了f(){}。繼承類需要你顯式的指定它的某個方法為synchronized方法。

線程的交互

wait()、notify()與notifyAll()

這里所提到的交互指java.lang.Object的類的三個方法：

?void notify()

????????? 喚醒在此對象監(jiān)視器上等待的單個線程。

?void notifyAll()

????????? 喚醒在此對象監(jiān)視器上等待的所有線程。

?void wait()

????????? 導(dǎo)致當(dāng)前的線程等待，直到其他線程調(diào)用此對象的 notify()方法或 notifyAll()方法。

當(dāng)然，wait()還有另外兩個重載方法：

?void wait(long timeout)

????????? 導(dǎo)致當(dāng)前的線程等待，直到其他線程調(diào)用此對象的 notify()方法或 notifyAll()方法，或者超過指定的時間量。

?void wait(long timeout, int nanos)

????????? 導(dǎo)致當(dāng)前的線程等待，直到其他線程調(diào)用此對象的 notify()方法或 notifyAll()方法，或者其他某個線程中斷當(dāng)前線程，或者已超過某個實(shí)際時間量。

以上這些方法是幫助線程傳遞線程關(guān)心的狀態(tài)。

來看一個實(shí)例：

//計(jì)算輸出其他線程鎖計(jì)算的數(shù)據(jù) public class ThreadA {public static void main(String[] args) {ThreadB b = new ThreadB();//啟動計(jì)算線程b.start();//線程A擁有b對象上的鎖。線程為了調(diào)用wait()或notify()方法，該線程必須是那個對象鎖的擁有者synchronized (b) {try {System.out.println("等待對象b完成計(jì)算。。。");//當(dāng)前線程A釋放對象b的鎖，放到對象b的等待隊(duì)列中，直到收到對象b發(fā)出notify()或者notifyAll()的信號。//注意，b.wait()并不是讓b等待，而是讓當(dāng)前線程等待bb.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("b對象計(jì)算的總和是："+ b.total);}} }//計(jì)算1+2+3 ...+100的和 public class ThreadB extends Thread {int total;public void run() {synchronized (this) {for (int i = 0; i < 101; i++) {total += i;}//（完成計(jì)算了）喚醒在此對象監(jiān)視器上等待的單個線程，在本例中線程A被喚醒notify();}} }?

多個線程在等待一個對象鎖時候使用notifyAll()

在多數(shù)情況下，最好通知等待某個對象的所有線程。如果這樣做，可以在對象上使用notifyAll()讓所有在此對象上等待的線程沖出等待區(qū)，返回到可運(yùn)行狀態(tài)。

依照上面的例子再寫一個實(shí)例：

//計(jì)算1+2+3 ...+100的和 public class Calculator extends Thread {int total;public void run() {synchronized (this) {for (int i = 0; i < 101; i++) {total += i;}try {Thread.sleep(1000);} catch(InterruptedException e) {e.printStackTrace();}notifyAll();}} }public class TestThread extends Thread{private Calculator calculator;public TestThread(Calculator c){this.calculator = c;}public void run(){synchronized (calculator) {try {System.out.println(Thread.currentThread() + "等待計(jì)算結(jié)果。。。");calculator.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread() + "計(jì)算結(jié)果為："+ calculator.total);}}public static void main(String[] args) {Calculator c = new Calculator();TestThread threadA = new TestThread(c);TestThread threadB = new TestThread(c);TestThread threadC = new TestThread(c);threadA.start();threadB.start();threadC.start();c.start();}}?

運(yùn)行程序，打印結(jié)果如下：

Thread[Thread-1,5,main]等待計(jì)算結(jié)果。。。

Thread[Thread-3,5,main]等待計(jì)算結(jié)果。。。

Thread[Thread-2,5,main]等待計(jì)算結(jié)果。。。

Thread[Thread-2,5,main]計(jì)算結(jié)果為：5050

Thread[Thread-3,5,main]計(jì)算結(jié)果為：5050

Thread[Thread-1,5,main]計(jì)算結(jié)果為：5050

雖然與我們預(yù)期的結(jié)果一樣，但是這是一個有漏洞的程序。下面將做具體分析。

threadA.start();

threadB.start();

threadC.start();

c.start();

這四行代碼雖然有先后順序，但是我們一再強(qiáng)調(diào)，調(diào)用start()方法之后線程并不一定立刻執(zhí)行，而是進(jìn)入到就緒狀態(tài)，至于先執(zhí)行哪個，后執(zhí)行哪個，由線程調(diào)度器隨機(jī)決定，是不可預(yù)測的。

假如線程c先執(zhí)行完畢，這時候threadA（或者threadB、threadC）還沒有執(zhí)行，那么問題就出現(xiàn)了，threadA需要等待c發(fā)出的notifyAll()信號，但是c早已執(zhí)行完畢，不可能在第二次執(zhí)行notifyAll()函數(shù)，threadA就會永遠(yuǎn)等下去。

因此，當(dāng)?shù)却氖录l(fā)生時，需要能夠檢查notifyAll()通知事件是否已經(jīng)發(fā)生。

通常，解決上面問題的最佳方式是利用某種循環(huán)，該循環(huán)檢查某個條件表達(dá)式，只有當(dāng)正在等待的事情還沒有發(fā)生的情況下，它才繼續(xù)等待。

當(dāng)在對象上調(diào)用wait()方法時，執(zhí)行該代碼的線程立即放棄它在對象上的鎖。然而調(diào)用notify()時，并不意味著這時線程會放棄其鎖。如果線程仍然在完成同步代碼，則線程在移出之前不會放棄鎖。因此，只要調(diào)用notify()并不意味著這時該鎖變得可用。

必須在同步環(huán)境內(nèi)調(diào)用wait()、notify()、notifyAll()方法。只有在線程擁有該對象的鎖時，才能調(diào)用這三個方法。

wait()、notify()、notifyAll()都是Object的實(shí)例方法。與每個對象具有鎖一樣，每個對象可以有一個線程列表，他們等待來自該信號（通知）。線程通過執(zhí)行對象上的wait()方法獲得這個等待列表。從那時候起，它不再執(zhí)行任何其他指令，直到調(diào)用對象的notify()方法為止。如果多個線程在同一個對象上等待，則將只選擇一個線程（不保證以何種順序）繼續(xù)執(zhí)行。如果沒有線程等待，則不采取任何特殊操作。

對比

初看wait()與notify()方法與 suspend()和resume()方法對沒有什么分別，但是事實(shí)上它們是截然不同的。區(qū)別的核心在于，前面敘述的所有方法，阻塞時都不會釋放占用的鎖（如果占用了的話），而這一對方法則相反。上述的核心區(qū)別導(dǎo)致了一系列的細(xì)節(jié)上的區(qū)別。

首先，前面敘述的所有方法都隸屬于Thread 類，但是這一對卻直接隸屬于 Object 類，也就是說，所有對象都擁有這一對方法。初看起來這十分不可思議，但是實(shí)際上卻是很自然的，因?yàn)檫@一對方法阻塞時要釋放占用的鎖，而鎖是任何對象都具有的，調(diào)用任意對象的 wait() 方法導(dǎo)致線程阻塞，并且該對象上的鎖被釋放。而調(diào)用任意對象的notify()方法則導(dǎo)致因調(diào)用該對象的 wait() 方法而阻塞的線程中隨機(jī)選擇的一個解除阻塞（但要等到獲得鎖后才真正可執(zhí)行）。

其次，前面敘述的所有方法都可在任何位置調(diào)用，但是這一對方法卻必須在 synchronized 方法或塊中調(diào)用，理由也很簡單，只有在synchronized 方法或塊中當(dāng)前線程才占有鎖，才有鎖可以釋放。同樣的道理，調(diào)用這一對方法的對象上的鎖必須為當(dāng)前線程所擁有，這樣才有鎖可以釋放。因此，這一對方法調(diào)用必須放置在這樣的 synchronized 方法或塊中，該方法或塊的上鎖對象就是調(diào)用這一對方法的對象。若不滿足這一條件，則程序雖然仍能編譯，但在運(yùn)行時會出現(xiàn)IllegalMonitorStateException 異常。

wait() 和 notify() 方法的上述特性決定了它們經(jīng)常和synchronized 方法或塊一起使用，將它們和操作系統(tǒng)的進(jìn)程間通信機(jī)制作一個比較就會發(fā)現(xiàn)它們的相似性：synchronized方法或塊提供了類似于操作系統(tǒng)原語的功能，它們的執(zhí)行不會受到多線程機(jī)制的干擾，而這一對方法則相當(dāng)于 block 和wakeup 原語（這一對方法均聲明為 synchronized）。它們的結(jié)合使得我們可以實(shí)現(xiàn)操作系統(tǒng)上一系列精妙的進(jìn)程間通信的算法（如信號量算法），并用于解決各種復(fù)雜的線程間通信問題。

關(guān)于 wait() 和 notify() 方法最后再說明兩點(diǎn)：

第一：調(diào)用 notify() 方法導(dǎo)致解除阻塞的線程是從因調(diào)用該對象的 wait() 方法而阻塞的線程中隨機(jī)選取的，我們無法預(yù)料哪一個線程將會被選擇，所以編程時要特別小心，避免因這種不確定性而產(chǎn)生問題。

第二：除了 notify()，notifyAll() 也可起到類似作用，唯一的區(qū)別在于，調(diào)用 notifyAll() 方法將把因調(diào)用該對象的 wait() 方法而阻塞的所有線程一次性全部解除阻塞。當(dāng)然，只有獲得鎖的那一個線程才能進(jìn)入可執(zhí)行狀態(tài)。

守護(hù)線程

守護(hù)線程是一類特殊的線程，它和普通線程的區(qū)別在于它并不是應(yīng)用程序的核心部分，當(dāng)一個應(yīng)用程序的所有非守護(hù)線程終止運(yùn)行時，即使仍然有守護(hù)線程在運(yùn)行，應(yīng)用程序也將終止，反之，只要有一個非守護(hù)線程在運(yùn)行，應(yīng)用程序就不會終止。守護(hù)線程一般被用于在后臺為其它線程提供服務(wù)。

可以通過調(diào)用方法 isDaemon() 來判斷一個線程是否是守護(hù)線程，也可以調(diào)用方法 setDaemon() 來將一個線程設(shè)為守護(hù)線程。該方法必須在啟動線程前調(diào)用。該方法首先調(diào)用該線程的 checkAccess方法，且不帶任何參數(shù)。這可能拋出 SecurityException（在當(dāng)前線程中）。

守護(hù)線程使用的情況較少，但并非無用，舉例來說，JVM的垃圾回收、內(nèi)存管理等線程都是守護(hù)線程。還有就是在做數(shù)據(jù)庫應(yīng)用時候，使用的數(shù)據(jù)庫連接池，連接池本身也包含著很多后臺線程，監(jiān)控連接個數(shù)、超時時間、狀態(tài)等等。

來看一個實(shí)例：

public class Test{public static void main(String[] args){Thread t1 = new MyCommon();Thread t2 = new Thread(new MyDaemon());t2.setDaemon(true); //設(shè)置為守護(hù)線程t2.start();t1.start();} }class MyCommon extends Thread {public void run() {for (int i = 0; i < 5; i++){System.out.println("線程1第" + i + "次執(zhí)行！");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 +"次執(zhí)行！");try {Thread.sleep(7);} catch(InterruptedException e) {e.printStackTrace();}}} }

打印結(jié)果：

后臺線程第0次執(zhí)行！

線程1第0次執(zhí)行！

線程1第1次執(zhí)行！

后臺線程第1次執(zhí)行！

后臺線程第2次執(zhí)行！

線程1第2次執(zhí)行！

線程1第3次執(zhí)行！

后臺線程第3次執(zhí)行！

線程1第4次執(zhí)行！

后臺線程第4次執(zhí)行！

后臺線程第5次執(zhí)行！

后臺線程第6次執(zhí)行！

后臺線程第7次執(zhí)行！

從上面的執(zhí)行結(jié)果可以看出，前臺線程是保證執(zhí)行完畢的，后臺線程還沒有執(zhí)行完畢就退出了。

實(shí)際上，JRE判斷程序是否執(zhí)行結(jié)束的標(biāo)準(zhǔn)是所有的前臺執(zhí)線程行完畢了，而不管后臺線程的狀態(tài)，因此，在使用后臺線程時候一定要注意這個問題。

線程組

線程組是一個 Java 特有的概念，在 Java 中，線程組是類ThreadGroup 的對象，每個線程都隸屬于唯一一個線程組，這個線程組在線程創(chuàng)建時指定并在線程的整個生命期內(nèi)都不能更改。

可以通過調(diào)用包含 ThreadGroup 類型參數(shù)的 Thread 類構(gòu)造函數(shù)來指定線程屬的線程組，若沒有指定，則線程缺省地隸屬于名為 system 的系統(tǒng)線程組。

在 Java 中，除了預(yù)建的系統(tǒng)線程組外，所有線程組都必須顯式創(chuàng)建。在 Java 中，除系統(tǒng)線程組外的每個線程組又隸屬于另一個線程組，可以在創(chuàng)建線程組時指定其所隸屬的線程組，若沒有指定，則缺省地隸屬于系統(tǒng)線程組。這樣，所有線程組組成了一棵以系統(tǒng)線程組為根的樹。

Java 允許我們對一個線程組中的所有線程同時進(jìn)行操作，比如我們可以通過調(diào)用線程組的相應(yīng)方法來設(shè)置其中所有線程的優(yōu)先級，也可以啟動或阻塞其中的所有線程。

Java 的線程組機(jī)制的另一個重要作用是線程安全。線程組機(jī)制允許我們通過分組來區(qū)分有不同安全特性的線程，對不同組的線程進(jìn)行不同的處理，還可以通過線程組的分層結(jié)構(gòu)來支持不對等安全措施的采用。Java 的 ThreadGroup 類提供了大量的方法來方便我們對線程組樹中的每一個線程組以及線程組中的每一個線程進(jìn)行操作。

轉(zhuǎn)載于:https://www.cnblogs.com/duadu/p/6335815.html

創(chuàng)作挑戰(zhàn)賽新人創(chuàng)作獎勵來咯，堅(jiān)持創(chuàng)作打卡瓜分現(xiàn)金大獎

總結(jié)

以上是生活随笔為你收集整理的多线程（初级篇）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。

多线程

编程问答

多线程（初级篇）

相關(guān)概念

線程的生命周期

線程的創(chuàng)建

1、繼承java.lang.Thread類

2、實(shí)現(xiàn)java.lang.Runnable接口

3、補(bǔ)充

線程的狀態(tài)裝換

sleep()方法

yield()方法

join()方法

interrupt()方法

其他方法

補(bǔ)充

線程的同步

同步

死鎖

volatile關(guān)鍵字

補(bǔ)充

線程的交互

wait()、notify()與notifyAll()

對比

守護(hù)線程

線程組

總結(jié)