本文主要講了java中多線程的使用方法烹植、線程同步悯舟、線程數(shù)據(jù)傳遞、線程狀態(tài)及相應(yīng)的一些線程函數(shù)用法拜效、概述等。

首先講一下進(jìn)程和線程的區(qū)別：

　　進(jìn)程：每個(gè)進(jìn)程都有獨(dú)立的代碼和數(shù)據(jù)空間（進(jìn)程上下文）并级，進(jìn)程間的切換會(huì)有較大的開銷拂檩，一個(gè)進(jìn)程包含1--n個(gè)線程。

　　線程：同一類線程共享代碼和數(shù)據(jù)空間嘲碧，每個(gè)線程有獨(dú)立的運(yùn)行棧和程序計(jì)數(shù)器(PC)，線程切換開銷小父阻。

　　線程和進(jìn)程一樣分為五個(gè)階段：創(chuàng)建愈涩、就緒、運(yùn)行加矛、阻塞履婉、終止。

　　多進(jìn)程是指操作系統(tǒng)能同時(shí)運(yùn)行多個(gè)任務(wù)（程序）斟览。

　　多線程是指在同一程序中有多個(gè)順序流在執(zhí)行毁腿。

在java中要想實(shí)現(xiàn)多線程，有兩種手段苛茂，一種是繼續(xù)Thread類已烤，另外一種是實(shí)現(xiàn)Runable接口。

一妓羊、擴(kuò)展java.lang.Thread類

package com.multithread.learning;

/**

*@functon 多線程學(xué)習(xí)

*@author 林炳文

*@time 2015.3.9

*/

class Thread1 extends Thread{

private String name;

? ?public Thread1(String name) {

? ? ? this.name=name;

? ?}

public void run() {

? ? ? ?for (int i = 0; i < 5; i++) {

? ? ? ? ? ?System.out.println(name + "運(yùn)行 ?: ?" + i);

? ? ? ? ? ?try {

? ? ? ? ? ? ? ?sleep((int) Math.random() * 10);

? ? ? ? ? ?} catch (InterruptedException e) {

? ? ? ? ? ? ? ?e.printStackTrace();

? ? ? ? ? ?}

? ? ? ?}

}

}

public class Main {

public static void main(String[] args) {

Thread1 mTh1=new Thread1("A");

Thread1 mTh2=new Thread1("B");

mTh1.start();

mTh2.start();

}

}輸出：

A運(yùn)行 ?: ?0

B運(yùn)行 ?: ?0

A運(yùn)行 ?: ?1

A運(yùn)行 ?: ?2

A運(yùn)行 ?: ?3

A運(yùn)行 ?: ?4

B運(yùn)行 ?: ?1

B運(yùn)行 ?: ?2

B運(yùn)行 ?: ?3

B運(yùn)行 ?: ?4

再運(yùn)行一下：

A運(yùn)行 ?: ?0

B運(yùn)行 ?: ?0

B運(yùn)行 ?: ?1

B運(yùn)行 ?: ?2

B運(yùn)行 ?: ?3

B運(yùn)行 ?: ?4

A運(yùn)行 ?: ?1

A運(yùn)行 ?: ?2

A運(yùn)行 ?: ?3

A運(yùn)行 ?: ?4

說明：

程序啟動(dòng)運(yùn)行main時(shí)候胯究，java虛擬機(jī)啟動(dòng)一個(gè)進(jìn)程，主線程main在main()調(diào)用時(shí)候被創(chuàng)建躁绸。隨著調(diào)用MitiSay的兩個(gè)對(duì)象的start方法裕循，另外兩個(gè)線程也啟動(dòng)了臣嚣，這樣，整個(gè)應(yīng)用就在多線程下運(yùn)行剥哑。

注意：start()方法的調(diào)用后并不是立即執(zhí)行多線程代碼硅则，而是使得該線程變?yōu)榭蛇\(yùn)行態(tài)（Runnable），什么時(shí)候運(yùn)行是由操作系統(tǒng)決定的株婴。

從程序運(yùn)行的結(jié)果可以發(fā)現(xiàn)抢埋，多線程程序是亂序執(zhí)行。因此督暂，只有亂序執(zhí)行的代碼才有必要設(shè)計(jì)為多線程揪垄。

Thread.sleep()方法調(diào)用目的是不讓當(dāng)前線程獨(dú)自霸占該進(jìn)程所獲取的CPU資源，以留出一定時(shí)間給其他線程執(zhí)行的機(jī)會(huì)逻翁。

實(shí)際上所有的多線程代碼執(zhí)行順序都是不確定的饥努，每次執(zhí)行的結(jié)果都是隨機(jī)的。

但是start方法重復(fù)調(diào)用的話八回，會(huì)出現(xiàn)java.lang.IllegalThreadStateException異常酷愧。

Thread1 mTh1=new Thread1("A");

Thread1 mTh2=mTh1;

mTh1.start();

mTh2.start();

輸出：

Exception in thread "main" java.lang.IllegalThreadStateException

? ?at java.lang.Thread.start(Unknown Source)

? ?at com.multithread.learning.Main.main(Main.java:31)

A運(yùn)行 ?: ?0

A運(yùn)行 ?: ?1

A運(yùn)行 ?: ?2

A運(yùn)行 ?: ?3

A運(yùn)行 ?: ?4

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

/**

*@functon 多線程學(xué)習(xí)

*@author 林炳文

*@time 2015.3.9

*/

package com.multithread.runnable;

class Thread2 implements Runnable{

private String name;

public Thread2(String name) {

this.name=name;

}

@Override

public void run() {

?for (int i = 0; i < 5; i++) {

? ? ? ? ? ?System.out.println(name + "運(yùn)行 ?: ?" + i);

? ? ? ? ? ?try {

? ? ? ? ? ? Thread.sleep((int) Math.random() * 10);

? ? ? ? ? ?} catch (InterruptedException e) {

? ? ? ? ? ? ? ?e.printStackTrace();

? ? ? ? ? ?}

? ? ? ?}

}

}

public class Main {

public static void main(String[] args) {

new Thread(new Thread2("C")).start();

new Thread(new Thread2("D")).start();

}

}輸出：

C運(yùn)行 ?: ?0

D運(yùn)行 ?: ?0

D運(yùn)行 ?: ?1

C運(yùn)行 ?: ?1

D運(yùn)行 ?: ?2

C運(yùn)行 ?: ?2

D運(yùn)行 ?: ?3

C運(yùn)行 ?: ?3

D運(yùn)行 ?: ?4

C運(yùn)行 ?: ?4

說明：

Thread2類通過實(shí)現(xiàn)Runnable接口缠诅，使得該類有了多線程類的特征溶浴。run（）方法是多線程程序的一個(gè)約定。所有的多線程代碼都在run方法里面管引。Thread類實(shí)際上也是實(shí)現(xiàn)了Runnable接口的類士败。

在啟動(dòng)的多線程的時(shí)候，需要先通過Thread類的構(gòu)造方法Thread(Runnable target) 構(gòu)造出對(duì)象褥伴，然后調(diào)用Thread對(duì)象的start()方法來(lái)運(yùn)行多線程代碼谅将。

實(shí)際上所有的多線程代碼都是通過運(yùn)行Thread的start()方法來(lái)運(yùn)行的。因此重慢，不管是擴(kuò)展Thread類還是實(shí)現(xiàn)Runnable接口來(lái)實(shí)現(xiàn)多線程饥臂，最終還是通過Thread的對(duì)象的API來(lái)控制線程的，熟悉Thread類的API是進(jìn)行多線程編程的基礎(chǔ)似踱。

三隅熙、Thread和Runnable的區(qū)別

如果一個(gè)類繼承Thread，則不適合資源共享核芽。但是如果實(shí)現(xiàn)了Runable接口的話囚戚，則很容易的實(shí)現(xiàn)資源共享。

package com.multithread.learning;

/**

*@functon 多線程學(xué)習(xí),繼承Thread狞洋，資源不能共享

*@author 林炳文

*@time 2015.3.9

*/

class Thread1 extends Thread{

private int count=5;

private String name;

? ?public Thread1(String name) {

? ? ? this.name=name;

? ?}

public void run() {

? ? ? ?for (int i = 0; i < 5; i++) {

? ? ? ? ? ?System.out.println(name + "運(yùn)行 ?count= " + count--);

? ? ? ? ? ?try {

? ? ? ? ? ? ? ?sleep((int) Math.random() * 10);

? ? ? ? ? ?} catch (InterruptedException e) {

? ? ? ? ? ? ? ?e.printStackTrace();

? ? ? ? ? ?}

? ? ? ?}

}

}

public class Main {

public static void main(String[] args) {

Thread1 mTh1=new Thread1("A");

Thread1 mTh2=new Thread1("B");

mTh1.start();

mTh2.start();

}

}

輸出：

B運(yùn)行 ?count= 5

A運(yùn)行 ?count= 5

B運(yùn)行 ?count= 4

B運(yùn)行 ?count= 3

B運(yùn)行 ?count= 2

B運(yùn)行 ?count= 1

A運(yùn)行 ?count= 4

A運(yùn)行 ?count= 3

A運(yùn)行 ?count= 2

A運(yùn)行 ?count= 1

從上面可以看出弯淘，不同的線程之間count是不同的，這對(duì)于賣票系統(tǒng)來(lái)說就會(huì)有很大的問題吉懊，當(dāng)然庐橙，這里可以用同步來(lái)作假勿。這里我們用Runnable來(lái)做下看看

/**

*@functon 多線程學(xué)習(xí) 繼承runnable，資源能共享

*@author 林炳文

*@time 2015.3.9

*/

package com.multithread.runnable;

class Thread2 implements Runnable{

? ?private int count=15;

@Override

public void run() {

?for (int i = 0; i < 5; i++) {

?System.out.println(Thread.currentThread().getName() + "運(yùn)行 ?count= " + count--);

? ? ? ? ? ?try {

? ? ? ? ? ? Thread.sleep((int) Math.random() * 10);

? ? ? ? ? ?} catch (InterruptedException e) {

? ? ? ? ? ? ? ?e.printStackTrace();

? ? ? ? ? ?}

? ? ? ?}

}

}

public class Main {

public static void main(String[] args) {

Thread2 my = new Thread2();

new Thread(my, "C").start();//同一個(gè)mt态鳖，但是在Thread中就不可以转培，如果用同一個(gè)實(shí)例化對(duì)象mt，就會(huì)出現(xiàn)異常

new Thread(my, "D").start();

new Thread(my, "E").start();

}

}

輸出：

C運(yùn)行 ?count= 15

D運(yùn)行 ?count= 14

E運(yùn)行 ?count= 13

D運(yùn)行 ?count= 12

D運(yùn)行 ?count= 10

D運(yùn)行 ?count= 9

D運(yùn)行 ?count= 8

C運(yùn)行 ?count= 11

E運(yùn)行 ?count= 12

C運(yùn)行 ?count= 7

E運(yùn)行 ?count= 6

C運(yùn)行 ?count= 5

E運(yùn)行 ?count= 4

C運(yùn)行 ?count= 3

E運(yùn)行 ?count= 2

這里要注意每個(gè)線程都是用同一個(gè)實(shí)例化對(duì)象浆竭，如果不是同一個(gè)浸须，效果就和上面的一樣了！

總結(jié)：

實(shí)現(xiàn)Runnable接口比繼承Thread類所具有的優(yōu)勢(shì)：

1）：適合多個(gè)相同的程序代碼的線程去處理同一個(gè)資源

2）：可以避免java中的單繼承的限制

3）：增加程序的健壯性邦泄，代碼可以被多個(gè)線程共享删窒，代碼和數(shù)據(jù)獨(dú)立

提醒一下大家：main方法其實(shí)也是一個(gè)線程。在java中所以的線程都是同時(shí)啟動(dòng)的顺囊，至于什么時(shí)候肌索，哪個(gè)先執(zhí)行，完全看誰(shuí)先得到CPU的資源特碳。

在java中诚亚，每次程序運(yùn)行至少啟動(dòng)2個(gè)線程。一個(gè)是main線程午乓，一個(gè)是垃圾收集線程站宗。因?yàn)槊慨?dāng)使用java命令執(zhí)行一個(gè)類的時(shí)候，實(shí)際上都會(huì)啟動(dòng)一個(gè)ＪＶＭ益愈，每一個(gè)ｊＶＭ實(shí)習(xí)在就是在操作系統(tǒng)中啟動(dòng)了一個(gè)進(jìn)程梢灭。

四、線程狀態(tài)轉(zhuǎn)換

技術(shù)分享

1腕唧、新建狀態(tài)（New）：新創(chuàng)建了一個(gè)線程對(duì)象或辖。

2、就緒狀態(tài)（Runnable）：線程對(duì)象創(chuàng)建后枣接，其他線程調(diào)用了該對(duì)象的start()方法。該狀態(tài)的線程位于可運(yùn)行線程池中缺谴，變得可運(yùn)行但惶，等待獲取CPU的使用權(quán)。

3湿蛔、運(yùn)行狀態(tài)（Running）：就緒狀態(tài)的線程獲取了CPU膀曾，執(zhí)行程序代碼。

4阳啥、阻塞狀態(tài)（Blocked）：阻塞狀態(tài)是線程因?yàn)槟撤N原因放棄CPU使用權(quán)添谊，暫時(shí)停止運(yùn)行。直到線程進(jìn)入就緒狀態(tài)察迟，才有機(jī)會(huì)轉(zhuǎn)到運(yùn)行狀態(tài)斩狱。阻塞的情況分三種：

（一）耳高、等待阻塞：運(yùn)行的線程執(zhí)行wait()方法，JVM會(huì)把該線程放入等待池中所踊。

（二）泌枪、同步阻塞：運(yùn)行的線程在獲取對(duì)象的同步鎖時(shí)，若該同步鎖被別的線程占用秕岛，則JVM會(huì)把該線程放入鎖池中碌燕。

（三）、其他阻塞：運(yùn)行的線程執(zhí)行sleep()或join()方法继薛，或者發(fā)出了I/O請(qǐng)求時(shí)修壕，JVM會(huì)把該線程置為阻塞狀態(tài)。當(dāng)sleep()狀態(tài)超時(shí)遏考、join()等待線程終止或者超時(shí)慈鸠、或者I/O處理完畢時(shí)，線程重新轉(zhuǎn)入就緒狀態(tài)诈皿。

5林束、死亡狀態(tài)（Dead）：線程執(zhí)行完了或者因異常退出了run()方法，該線程結(jié)束生命周期稽亏。

五壶冒、線程調(diào)度

線程的調(diào)度

1、調(diào)整線程優(yōu)先級(jí)：Java線程有優(yōu)先級(jí)截歉，優(yōu)先級(jí)高的線程會(huì)獲得較多的運(yùn)行機(jī)會(huì)胖腾。

Java線程的優(yōu)先級(jí)用整數(shù)表示，取值范圍是1~10瘪松，Thread類有以下三個(gè)靜態(tài)常量：

static int MAX_PRIORITY

線程可以具有的最高優(yōu)先級(jí)咸作，取值為10。

static int MIN_PRIORITY

線程可以具有的最低優(yōu)先級(jí)宵睦，取值為1记罚。

static int NORM_PRIORITY

分配給線程的默認(rèn)優(yōu)先級(jí)，取值為5壳嚎。

Thread類的setPriority()和getPriority()方法分別用來(lái)設(shè)置和獲取線程的優(yōu)先級(jí)桐智。

每個(gè)線程都有默認(rèn)的優(yōu)先級(jí)。主線程的默認(rèn)優(yōu)先級(jí)為Thread.NORM_PRIORITY烟馅。

線程的優(yōu)先級(jí)有繼承關(guān)系说庭，比如A線程中創(chuàng)建了B線程，那么B將和A具有相同的優(yōu)先級(jí)郑趁。

JVM提供了10個(gè)線程優(yōu)先級(jí)刊驴，但與常見的操作系統(tǒng)都不能很好的映射。如果希望程序能移植到各個(gè)操作系統(tǒng)中，應(yīng)該僅僅使用Thread類有以下三個(gè)靜態(tài)常量作為優(yōu)先級(jí)捆憎，這樣能保證同樣的優(yōu)先級(jí)采用了同樣的調(diào)度方式舅柜。

2、線程睡眠：Thread.sleep(long millis)方法攻礼，使線程轉(zhuǎn)到阻塞狀態(tài)业踢。millis參數(shù)設(shè)定睡眠的時(shí)間，以毫秒為單位礁扮。當(dāng)睡眠結(jié)束后知举，就轉(zhuǎn)為就緒（Runnable）狀態(tài)。sleep()平臺(tái)移植性好太伊。

3雇锡、線程等待：Object類中的wait()方法，導(dǎo)致當(dāng)前的線程等待僚焦，直到其他線程調(diào)用此對(duì)象的 notify() 方法或 notifyAll() 喚醒方法锰提。這個(gè)兩個(gè)喚醒方法也是Object類中的方法，行為等價(jià)于調(diào)用 wait(0) 一樣芳悲。

4立肘、線程讓步：Thread.yield() 方法，暫停當(dāng)前正在執(zhí)行的線程對(duì)象名扛，把執(zhí)行機(jī)會(huì)讓給相同或者更高優(yōu)先級(jí)的線程谅年。

5、線程加入：join()方法肮韧，等待其他線程終止融蹂。在當(dāng)前線程中調(diào)用另一個(gè)線程的join()方法，則當(dāng)前線程轉(zhuǎn)入阻塞狀態(tài)弄企，直到另一個(gè)進(jìn)程運(yùn)行結(jié)束台丛，當(dāng)前線程再由阻塞轉(zhuǎn)為就緒狀態(tài)胚委。

6皮胡、線程喚醒：Object類中的notify()方法烫罩，喚醒在此對(duì)象監(jiān)視器上等待的單個(gè)線程。如果所有線程都在此對(duì)象上等待约素，則會(huì)選擇喚醒其中一個(gè)線程洽瞬。選擇是任意性的，并在對(duì)實(shí)現(xiàn)做出決定時(shí)發(fā)生业汰。線程通過調(diào)用其中一個(gè) wait 方法，在對(duì)象的監(jiān)視器上等待菩颖。 直到當(dāng)前的線程放棄此對(duì)象上的鎖定样漆，才能繼續(xù)執(zhí)行被喚醒的線程。被喚醒的線程將以常規(guī)方式與在該對(duì)象上主動(dòng)同步的其他所有線程進(jìn)行競(jìng)爭(zhēng)晦闰；例如放祟，喚醒的線程在作為鎖定此對(duì)象的下一個(gè)線程方面沒有可靠的特權(quán)或劣勢(shì)鳍怨。類似的方法還有一個(gè)notifyAll()，喚醒在此對(duì)象監(jiān)視器上等待的所有線程跪妥。

注意：Thread中suspend()和resume()兩個(gè)方法在JDK1.5中已經(jīng)廢除鞋喇，不再介紹。因?yàn)橛兴梨i傾向眉撵。

六侦香、常用函數(shù)說明

①sleep(long millis): 在指定的毫秒數(shù)內(nèi)讓當(dāng)前正在執(zhí)行的線程休眠（暫停執(zhí)行）

②join():指等待t線程終止。

使用方式纽疟。

join是Thread類的一個(gè)方法罐韩，啟動(dòng)線程后直接調(diào)用，即join()的作用是：“等待該線程終止”污朽，這里需要理解的就是該線程是指的主線程等待子線程的終止散吵。也就是在子線程調(diào)用了join()方法后面的代碼，只有等到子線程結(jié)束了才能執(zhí)行蟆肆。

Thread t = new AThread(); t.start(); t.join();

為什么要用join()方法

在很多情況下矾睦，主線程生成并起動(dòng)了子線程，如果子線程里要進(jìn)行大量的耗時(shí)的運(yùn)算炎功，主線程往往將于子線程之前結(jié)束枚冗，但是如果主線程處理完其他的事務(wù)后，需要用到子線程的處理結(jié)果亡问，也就是主線程需要等待子線程執(zhí)行完成之后再結(jié)束官紫，這個(gè)時(shí)候就要用到j(luò)oin()方法了。

不加join州藕。

/**

*@functon 多線程學(xué)習(xí),join

*@author 林炳文

*@time 2015.3.9

*/

package com.multithread.join;

class Thread1 extends Thread{

private String name;

public Thread1(String name) {

super(name);

this.name=name;

}

public void run() {

System.out.println(Thread.currentThread().getName() + " 線程運(yùn)行開始!");

for (int i = 0; i < 5; i++) {

System.out.println("子線程"+name + "運(yùn)行 : " + i);

try {

sleep((int) Math.random() * 10);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

System.out.println(Thread.currentThread().getName() + " 線程運(yùn)行結(jié)束!");

}

}

public class Main {

public static void main(String[] args) {

System.out.println(Thread.currentThread().getName()+"主線程運(yùn)行開始!");

Thread1 mTh1=new Thread1("A");

Thread1 mTh2=new Thread1("B");

mTh1.start();

mTh2.start();

System.out.println(Thread.currentThread().getName()+ "主線程運(yùn)行結(jié)束!");

}

}

輸出結(jié)果：

main主線程運(yùn)行開始!

main主線程運(yùn)行結(jié)束!

B 線程運(yùn)行開始!

子線程B運(yùn)行 : 0

A 線程運(yùn)行開始!

子線程A運(yùn)行 : 0

子線程B運(yùn)行 : 1

子線程A運(yùn)行 : 1

子線程A運(yùn)行 : 2

子線程A運(yùn)行 : 3

子線程A運(yùn)行 : 4

A 線程運(yùn)行結(jié)束!

子線程B運(yùn)行 : 2

子線程B運(yùn)行 : 3

子線程B運(yùn)行 : 4

B 線程運(yùn)行結(jié)束!

發(fā)現(xiàn)主線程比子線程早結(jié)束

加join

public class Main {

public static void main(String[] args) {

System.out.println(Thread.currentThread().getName()+"主線程運(yùn)行開始!");

Thread1 mTh1=new Thread1("A");

Thread1 mTh2=new Thread1("B");

mTh1.start();

mTh2.start();

try {

mTh1.join();

} catch (InterruptedException e) {

e.printStackTrace();

}

try {

mTh2.join();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+ "主線程運(yùn)行結(jié)束!");

}

}

運(yùn)行結(jié)果：

main主線程運(yùn)行開始!

A 線程運(yùn)行開始!

子線程A運(yùn)行 : 0

B 線程運(yùn)行開始!

子線程B運(yùn)行 : 0

子線程A運(yùn)行 : 1

子線程B運(yùn)行 : 1

子線程A運(yùn)行 : 2

子線程B運(yùn)行 : 2

子線程A運(yùn)行 : 3

子線程B運(yùn)行 : 3

子線程A運(yùn)行 : 4

子線程B運(yùn)行 : 4

A 線程運(yùn)行結(jié)束!

主線程一定會(huì)等子線程都結(jié)束了才結(jié)束

③yield():暫停當(dāng)前正在執(zhí)行的線程對(duì)象束世，并執(zhí)行其他線程。

Thread.yield()方法作用是：暫停當(dāng)前正在執(zhí)行的線程對(duì)象床玻，并執(zhí)行其他線程毁涉。

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

結(jié)論：yield()從未導(dǎo)致線程轉(zhuǎn)到等待/睡眠/阻塞狀態(tài)缨该。在大多數(shù)情況下偎行，yield()將導(dǎo)致線程從運(yùn)行狀態(tài)轉(zhuǎn)到可運(yùn)行狀態(tài)，但有可能沒有效果「蛱唬可看上面的圖熄云。

/**

*@functon 多線程學(xué)習(xí) yield

*@author 林炳文

*@time 2015.3.9

*/

package com.multithread.yield;

class ThreadYield extends Thread{

public ThreadYield(String name) {

super(name);

}

@Override

public void run() {

for (int i = 1; i <= 50; i++) {

System.out.println("" + this.getName() + "-----" + i);

// 當(dāng)i為30時(shí)，該線程就會(huì)把CPU時(shí)間讓掉妙真，讓其他或者自己的線程執(zhí)行（也就是誰(shuí)先搶到誰(shuí)執(zhí)行）

if (i ==30) {

this.yield();

}

}

}

}

public class Main {

public static void main(String[] args) {

ThreadYield yt1 = new ThreadYield("張三");

ThreadYield yt2 = new ThreadYield("李四");

yt1.start();

yt2.start();

}

}

運(yùn)行結(jié)果：

第一種情況：李四（線程）當(dāng)執(zhí)行到30時(shí)會(huì)CPU時(shí)間讓掉缴允，這時(shí)張三（線程）搶到CPU時(shí)間并執(zhí)行。

第二種情況：李四（線程）當(dāng)執(zhí)行到30時(shí)會(huì)CPU時(shí)間讓掉珍德，這時(shí)李四（線程）搶到CPU時(shí)間并執(zhí)行练般。

sleep()和yield()的區(qū)別

sleep()和yield()的區(qū)別):sleep()使當(dāng)前線程進(jìn)入停滯狀態(tài)，所以執(zhí)行sleep()的線程在指定的時(shí)間內(nèi)肯定不會(huì)被執(zhí)行菱阵；yield()只是使當(dāng)前線程重新回到可執(zhí)行狀態(tài)踢俄，所以執(zhí)行yield()的線程有可能在進(jìn)入到可執(zhí)行狀態(tài)后馬上又被執(zhí)行。

sleep 方法使當(dāng)前運(yùn)行中的線程睡眼一段時(shí)間晴及，進(jìn)入不可運(yùn)行狀態(tài)都办，這段時(shí)間的長(zhǎng)短是由程序設(shè)定的，yield 方法使當(dāng)前線程讓出 CPU 占有權(quán)虑稼，但讓出的時(shí)間是不可設(shè)定的琳钉。實(shí)際上，yield()方法對(duì)應(yīng)了如下操作：先檢測(cè)當(dāng)前是否有相同優(yōu)先級(jí)的線程處于同可運(yùn)行狀態(tài)蛛倦，如有歌懒，則把 CPU ?的占有權(quán)交給此線程，否則溯壶，繼續(xù)運(yùn)行原來(lái)的線程及皂。所以yield()方法稱為“退讓”，它把運(yùn)行機(jī)會(huì)讓給了同等優(yōu)先級(jí)的其他線程

另外且改，sleep 方法允許較低優(yōu)先級(jí)的線程獲得運(yùn)行機(jī)會(huì)验烧，但 yield() ?方法執(zhí)行時(shí)，當(dāng)前線程仍處在可運(yùn)行狀態(tài)又跛，所以碍拆，不可能讓出較低優(yōu)先級(jí)的線程些時(shí)獲得 CPU 占有權(quán)。在一個(gè)運(yùn)行系統(tǒng)中慨蓝，如果較高優(yōu)先級(jí)的線程沒有調(diào)用 sleep 方法感混，又沒有受到 I\O 阻塞，那么礼烈，較低優(yōu)先級(jí)線程只能等待所有較高優(yōu)先級(jí)的線程運(yùn)行結(jié)束弧满，才有機(jī)會(huì)運(yùn)行。

④setPriority(): 更改線程的優(yōu)先級(jí)此熬。

　　　　MIN_PRIORITY = 1

?　　 ? NORM_PRIORITY = 5

? ? ? ? ? MAX_PRIORITY = 10

用法：

Thread4 t1 = new Thread4("t1");

Thread4 t2 = new Thread4("t2");

t1.setPriority(Thread.MAX_PRIORITY);

t2.setPriority(Thread.MIN_PRIORITY);

⑤interrupt():中斷某個(gè)線程谱秽，這種結(jié)束方式比較粗暴洽蛀，如果t線程打開了某個(gè)資源還沒來(lái)得及關(guān)閉也就是run方法還沒有執(zhí)行完就強(qiáng)制結(jié)束線程，會(huì)導(dǎo)致資源無(wú)法關(guān)閉

　　要想結(jié)束進(jìn)程最好的辦法就是用sleep()函數(shù)的例子程序里那樣疟赊，在線程類里面用以個(gè)boolean型變量來(lái)控制run()方法什么時(shí)候結(jié)束，run()方法一結(jié)束峡碉，該線程也就結(jié)束了近哟。

⑥wait()

Obj.wait()，與Obj.notify()必須要與synchronized(Obj)一起使用鲫寄，也就是wait,與notify是針對(duì)已經(jīng)獲取了Obj鎖進(jìn)行操作吉执，從語(yǔ)法角度來(lái)說就是Obj.wait(),Obj.notify必須在synchronized(Obj){...}語(yǔ)句塊內(nèi)。從功能上來(lái)說wait就是說線程在獲取對(duì)象鎖后地来，主動(dòng)釋放對(duì)象鎖戳玫，同時(shí)本線程休眠。直到有其它線程調(diào)用對(duì)象的notify()喚醒該線程未斑，才能繼續(xù)獲取對(duì)象鎖咕宿，并繼續(xù)執(zhí)行。相應(yīng)的notify()就是對(duì)對(duì)象鎖的喚醒操作蜡秽。但有一點(diǎn)需要注意的是notify()調(diào)用后府阀，并不是馬上就釋放對(duì)象鎖的，而是在相應(yīng)的synchronized(){}語(yǔ)句塊執(zhí)行結(jié)束芽突，自動(dòng)釋放鎖后试浙，JVM會(huì)在wait()對(duì)象鎖的線程中隨機(jī)選取一線程，賦予其對(duì)象鎖寞蚌，喚醒線程田巴，繼續(xù)執(zhí)行。這樣就提供了在線程間同步挟秤、喚醒的操作壹哺。Thread.sleep()與Object.wait()二者都可以暫停當(dāng)前線程，釋放CPU控制權(quán)煞聪，主要的區(qū)別在于Object.wait()在釋放CPU同時(shí)斗躏，釋放了對(duì)象鎖的控制。

? ?單單在概念上理解清楚了還不夠昔脯，需要在實(shí)際的例子中進(jìn)行測(cè)試才能更好的理解啄糙。對(duì)Object.wait()，Object.notify()的應(yīng)用最經(jīng)典的例子云稚，應(yīng)該是三線程打印ABC的問題了吧隧饼，這是一道比較經(jīng)典的面試題，題目要求如下：

? ?建立三個(gè)線程静陈，A線程打印10次A燕雁，B線程打印10次B,C線程打印10次C诞丽，要求線程同時(shí)運(yùn)行，交替打印10次ABC拐格。這個(gè)問題用Object的wait()僧免，notify()就可以很方便的解決。代碼如下：

/**

* wait用法

* @author DreamSea

* @time 2015.3.9

*/

package com.multithread.wait;

public class MyThreadPrinter2 implements Runnable {

private String name;

private Object prev;

private Object self;

private MyThreadPrinter2(String name, Object prev, Object self) {

this.name = name;

this.prev = prev;

this.self = self;

}

@Override

public void run() {

int count = 10;

while (count > 0) {

synchronized (prev) {

synchronized (self) {

System.out.print(name);

count--;

self.notify();

}

try {

prev.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

public static void main(String[] args) throws Exception {

Object a = new Object();

Object b = new Object();

Object c = new Object();

MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);

MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);

MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);

new Thread(pa).start();

Thread.sleep(100); ?//確保按順序A捏浊、B懂衩、C執(zhí)行

new Thread(pb).start();

Thread.sleep(100);

new Thread(pc).start();

Thread.sleep(100);

}

}

輸出結(jié)果：

ABCABCABCABCABCABCABCABCABCABC

? ? 先來(lái)解釋一下其整體思路，從大的方向上來(lái)講金踪，該問題為三線程間的同步喚醒操作浊洞，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循環(huán)執(zhí)行三個(gè)線程。為了控制線程執(zhí)行的順序胡岔，那么就必須要確定喚醒法希、等待的順序，所以每一個(gè)線程必須同時(shí)持有兩個(gè)對(duì)象鎖靶瘸，才能繼續(xù)執(zhí)行苫亦。一個(gè)對(duì)象鎖是prev，就是前一個(gè)線程所持有的對(duì)象鎖奕锌。還有一個(gè)就是自身對(duì)象鎖著觉。主要的思想就是，為了控制執(zhí)行的順序惊暴，必須要先持有prev鎖饼丘，也就前一個(gè)線程要釋放自身對(duì)象鎖，再去申請(qǐng)自身對(duì)象鎖辽话，兩者兼?zhèn)鋾r(shí)打印肄鸽，之后首先調(diào)用self.notify()釋放自身對(duì)象鎖，喚醒下一個(gè)等待線程油啤，再調(diào)用prev.wait()釋放prev對(duì)象鎖典徘，終止當(dāng)前線程，等待循環(huán)結(jié)束后再次被喚醒益咬。運(yùn)行上述代碼逮诲，可以發(fā)現(xiàn)三個(gè)線程循環(huán)打印ABC，共10次幽告。程序運(yùn)行的主要過程就是A線程最先運(yùn)行梅鹦，持有C,A對(duì)象鎖，后釋放A,C鎖冗锁，喚醒B齐唆。線程B等待A鎖，再申請(qǐng)B鎖冻河，后打印B箍邮，再釋放B茉帅，A鎖，喚醒C锭弊，線程C等待B鎖堪澎，再申請(qǐng)C鎖，后打印C廷蓉，再釋放C,B鎖全封，喚醒A√胰看起來(lái)似乎沒什么問題，但如果你仔細(xì)想一下行楞，就會(huì)發(fā)現(xiàn)有問題攒暇，就是初始條件，三個(gè)線程按照A,B,C的順序來(lái)啟動(dòng)子房，按照前面的思考形用，A喚醒B，B喚醒C证杭，C再喚醒A田度。但是這種假設(shè)依賴于JVM中線程調(diào)度、執(zhí)行的順序解愤。

wait和sleep區(qū)別

共同點(diǎn)：

1. 他們都是在多線程的環(huán)境下镇饺，都可以在程序的調(diào)用處阻塞指定的毫秒數(shù)，并返回送讲。

2. wait()和sleep()都可以通過interrupt()方法 打斷線程的暫停狀態(tài) 奸笤，從而使線程立刻拋出InterruptedException。

如果線程A希望立即結(jié)束線程B哼鬓，則可以對(duì)線程B對(duì)應(yīng)的Thread實(shí)例調(diào)用interrupt方法监右。如果此刻線程B正在wait/sleep /join，則線程B會(huì)立刻拋出InterruptedException异希，在catch() {} 中直接return即可安全地結(jié)束線程健盒。

需要注意的是，InterruptedException是線程自己從內(nèi)部拋出的称簿，并不是interrupt()方法拋出的扣癣。對(duì)某一線程調(diào)用 interrupt()時(shí)，如果該線程正在執(zhí)行普通的代碼予跌，那么該線程根本就不會(huì)拋出InterruptedException搏色。但是，一旦該線程進(jìn)入到 wait()/sleep()/join()后券册，就會(huì)立刻拋出InterruptedException 频轿。

不同點(diǎn)：

1. Thread類的方法：sleep(),yield()等

Object的方法：wait()和notify()等

2. 每個(gè)對(duì)象都有一個(gè)鎖來(lái)控制同步訪問垂涯。Synchronized關(guān)鍵字可以和對(duì)象的鎖交互，來(lái)實(shí)現(xiàn)線程的同步航邢。

sleep方法沒有釋放鎖耕赘，而wait方法釋放了鎖，使得其他線程可以使用同步控制塊或者方法膳殷。

3. wait操骡，notify和notifyAll只能在同步控制方法或者同步控制塊里面使用，而sleep可以在任何地方使用

4. sleep必須捕獲異常赚窃，而wait册招，notify和notifyAll不需要捕獲異常

所以sleep()和wait()方法的最大區(qū)別是：

　　　　sleep()睡眠時(shí)，保持對(duì)象鎖勒极，仍然占有該鎖是掰；

　　　　而wait()睡眠時(shí)，釋放對(duì)象鎖辱匿。

　　但是wait()和sleep()都可以通過interrupt()方法打斷線程的暫停狀態(tài)键痛，從而使線程立刻拋出InterruptedException（但不建議使用該方法）。

sleep（）方法

sleep()使當(dāng)前線程進(jìn)入停滯狀態(tài)（阻塞當(dāng)前線程）匾七，讓出CUP的使用絮短、目的是不讓當(dāng)前線程獨(dú)自霸占該進(jìn)程所獲的CPU資源，以留一定時(shí)間給其他線程執(zhí)行的機(jī)會(huì);

　　 sleep()是Thread類的Static(靜態(tài))的方法昨忆；因此他不能改變對(duì)象的機(jī)鎖丁频，所以當(dāng)在一個(gè)Synchronized塊中調(diào)用Sleep()方法是，線程雖然休眠了扔嵌，但是對(duì)象的機(jī)鎖并木有被釋放限府，其他線程無(wú)法訪問這個(gè)對(duì)象（即使睡著也持有對(duì)象鎖）。

　　在sleep()休眠時(shí)間期滿后痢缎，該線程不一定會(huì)立即執(zhí)行胁勺，這是因?yàn)槠渌€程可能正在運(yùn)行而且沒有被調(diào)度為放棄執(zhí)行，除非此線程具有更高的優(yōu)先級(jí)独旷。

wait（）方法

wait()方法是Object類里的方法署穗；當(dāng)一個(gè)線程執(zhí)行到wait()方法時(shí)，它就進(jìn)入到一個(gè)和該對(duì)象相關(guān)的等待池中嵌洼，同時(shí)失去（釋放）了對(duì)象的機(jī)鎖（暫時(shí)失去機(jī)鎖案疲，wait(long timeout)超時(shí)時(shí)間到后還需要返還對(duì)象鎖）；其他線程可以訪問麻养；

　　wait()使用notify或者notifyAlll或者指定睡眠時(shí)間來(lái)喚醒當(dāng)前等待池中的線程褐啡。

　　wiat()必須放在synchronized block中，否則會(huì)在program runtime時(shí)扔出”java.lang.IllegalMonitorStateException“異常鳖昌。

七备畦、常見線程名詞解釋

主線程：JVM調(diào)用程序main()所產(chǎn)生的線程低飒。

當(dāng)前線程：這個(gè)是容易混淆的概念。一般指通過Thread.currentThread()來(lái)獲取的進(jìn)程懂盐。

后臺(tái)線程：指為其他線程提供服務(wù)的線程褥赊，也稱為守護(hù)線程。JVM的垃圾回收線程就是一個(gè)后臺(tái)線程莉恼。用戶線程和守護(hù)線程的區(qū)別在于拌喉，是否等待主線程依賴于主線程結(jié)束而結(jié)束

前臺(tái)線程：是指接受后臺(tái)線程服務(wù)的線程，其實(shí)前臺(tái)后臺(tái)線程是聯(lián)系在一起俐银，就像傀儡和幕后操縱者一樣的關(guān)系尿背。傀儡是前臺(tái)線程捶惜、幕后操縱者是后臺(tái)線程残家。由前臺(tái)線程創(chuàng)建的線程默認(rèn)也是前臺(tái)線程∈墼辏可以通過isDaemon()和setDaemon()方法來(lái)判斷和設(shè)置一個(gè)線程是否為后臺(tái)線程。

線程類的一些常用方法：

　　sleep(): 強(qiáng)迫一個(gè)線程睡眠Ｎ毫秒茴晋。

　　isAlive(): 判斷一個(gè)線程是否存活陪捷。

　　join(): 等待線程終止。

　　activeCount(): 程序中活躍的線程數(shù)诺擅。

　　enumerate(): 枚舉程序中的線程市袖。

currentThread(): 得到當(dāng)前線程。

　　isDaemon(): 一個(gè)線程是否為守護(hù)線程烁涌。

　　setDaemon(): 設(shè)置一個(gè)線程為守護(hù)線程苍碟。(用戶線程和守護(hù)線程的區(qū)別在于，是否等待主線程依賴于主線程結(jié)束而結(jié)束)

　　setName(): 為線程設(shè)置一個(gè)名稱撮执。

　　wait(): 強(qiáng)迫一個(gè)線程等待微峰。

　　notify(): 通知一個(gè)線程繼續(xù)運(yùn)行。

　　setPriority(): 設(shè)置一個(gè)線程的優(yōu)先級(jí)抒钱。

八蜓肆、線程同步

1、synchronized關(guān)鍵字的作用域有二種：

1）是某個(gè)對(duì)象實(shí)例內(nèi)谋币，synchronized aMethod(){}可以防止多個(gè)線程同時(shí)訪問這個(gè)對(duì)象的synchronized方法（如果一個(gè)對(duì)象有多個(gè)synchronized方法仗扬，只要一個(gè)線程訪問了其中的一個(gè)synchronized方法，其它線程不能同時(shí)訪問這個(gè)對(duì)象中任何一個(gè)synchronized方法）蕾额。這時(shí)早芭，不同的對(duì)象實(shí)例的synchronized方法是不相干擾的。也就是說诅蝶，其它線程照樣可以同時(shí)訪問相同類的另一個(gè)對(duì)象實(shí)例中的synchronized方法退个；

2）是某個(gè)類的范圍募壕，synchronized static aStaticMethod{}防止多個(gè)線程同時(shí)訪問這個(gè)類中的synchronized static 方法。它可以對(duì)類的所有對(duì)象實(shí)例起作用帜乞。

2司抱、除了方法前用synchronized關(guān)鍵字，synchronized關(guān)鍵字還可以用于方法中的某個(gè)區(qū)塊中黎烈，表示只對(duì)這個(gè)區(qū)塊的資源實(shí)行互斥訪問习柠。用法是: synchronized(this){/*區(qū)塊*/}，它的作用域是當(dāng)前對(duì)象照棋；

3资溃、synchronized關(guān)鍵字是不能繼承的，也就是說烈炭，基類的方法synchronized f(){} 在繼承類中并不自動(dòng)是synchronized f(){}溶锭，而是變成了f(){}。繼承類需要你顯式的指定它的某個(gè)方法為synchronized方法符隙；

Java對(duì)多線程的支持與同步機(jī)制深受大家的喜愛趴捅，似乎看起來(lái)使用了synchronized關(guān)鍵字就可以輕松地解決多線程共享數(shù)據(jù)同步問題。到底如何霹疫？――還得對(duì)synchronized關(guān)鍵字的作用進(jìn)行深入了解才可定論拱绑。

總的說來(lái)，synchronized關(guān)鍵字可以作為函數(shù)的修飾符丽蝎，也可作為函數(shù)內(nèi)的語(yǔ)句猎拨，也就是平時(shí)說的同步方法和同步語(yǔ)句塊。如果再細(xì)的分類屠阻，synchronized可作用于instance變量红省、object reference（對(duì)象引用）、static函數(shù)和class literals(類名稱字面常量)身上国觉。

在進(jìn)一步闡述之前吧恃，我們需要明確幾點(diǎn)：

A．無(wú)論synchronized關(guān)鍵字加在方法上還是對(duì)象上，它取得的鎖都是對(duì)象蛉加，而不是把一段代碼或函數(shù)當(dāng)作鎖――而且同步方法很可能還會(huì)被其他線程的對(duì)象訪問蚜枢。

B．每個(gè)對(duì)象只有一個(gè)鎖（lock）與之相關(guān)聯(lián)。

C．實(shí)現(xiàn)同步是要很大的系統(tǒng)開銷作為代價(jià)的针饥，甚至可能造成死鎖厂抽，所以盡量避免無(wú)謂的同步控制。

接著來(lái)討論synchronized用到不同地方對(duì)代碼產(chǎn)生的影響：

假設(shè)P1丁眼、P2是同一個(gè)類的不同對(duì)象筷凤，這個(gè)類中定義了以下幾種情況的同步塊或同步方法，P1、P2就都可以調(diào)用它們藐守。

1． ?把synchronized當(dāng)作函數(shù)修飾符時(shí)挪丢，示例代碼如下：

Public synchronized void methodAAA()

{

//….

}

這也就是同步方法，那這時(shí)synchronized鎖定的是哪個(gè)對(duì)象呢卢厂？它鎖定的是調(diào)用這個(gè)同步方法對(duì)象乾蓬。也就是說，當(dāng)一個(gè)對(duì)象P1在不同的線程中執(zhí)行這個(gè)同步方法時(shí)慎恒，它們之間會(huì)形成互斥任内，達(dá)到同步的效果。但是這個(gè)對(duì)象所屬的Class所產(chǎn)生的另一對(duì)象P2卻可以任意調(diào)用這個(gè)被加了synchronized關(guān)鍵字的方法融柬。

上邊的示例代碼等同于如下代碼：

public void methodAAA()

{

synchronized (this) ? ? ?// ?(1)

{

? ? ? //…..

}

}

(1)處的this指的是什么呢死嗦？它指的就是調(diào)用這個(gè)方法的對(duì)象，如P1粒氧≡匠可見同步方法實(shí)質(zhì)是將synchronized作用于object reference。――那個(gè)拿到了P1對(duì)象鎖的線程外盯，才可以調(diào)用P1的同步方法摘盆，而對(duì)P2而言，P1這個(gè)鎖與它毫不相干饱苟，程序也可能在這種情形下擺脫同步機(jī)制的控制骡澈，造成數(shù)據(jù)混亂：（

2．同步塊，示例代碼如下：

? ? ? ? ? ?public void method3(SomeObject so)

? ? ? ? ? ? ?{

? ? ? ? ? ? ? ? ? ? synchronized(so)

{

? ? ? //…..

}

}

這時(shí)掷空，鎖就是so這個(gè)對(duì)象，誰(shuí)拿到這個(gè)鎖誰(shuí)就可以運(yùn)行它所控制的那段代碼囤锉。當(dāng)有一個(gè)明確的對(duì)象作為鎖時(shí)坦弟，就可以這樣寫程序，但當(dāng)沒有明確的對(duì)象作為鎖官地，只是想讓一段代碼同步時(shí)酿傍，可以創(chuàng)建一個(gè)特殊的instance變量（它得是一個(gè)對(duì)象）來(lái)充當(dāng)鎖：

class Foo implements Runnable

{

? ? ? private byte[] lock = new byte[0]; ?// 特殊的instance變量

? ?Public void methodA()

{

? ? ? synchronized(lock) { //… }

}

//…..

}

注：零長(zhǎng)度的byte數(shù)組對(duì)象創(chuàng)建起來(lái)將比任何對(duì)象都經(jīng)濟(jì)――查看編譯后的字節(jié)碼：生成零長(zhǎng)度的byte[]對(duì)象只需3條操作碼，而Object lock = new Object()則需要7行操作碼驱入。

3．將synchronized作用于static 函數(shù)赤炒，示例代碼如下：

? ? ?Class Foo

{

public synchronized static void methodAAA() ? // 同步的static 函數(shù)

{

//….

}

public void methodBBB()

{

? ? ? synchronized(Foo.class) ? // ?class literal(類名稱字面常量)

}

? ? ? }

? 代碼中的methodBBB()方法是把class literal作為鎖的情況，它和同步的static函數(shù)產(chǎn)生的效果是一樣的亏较，取得的鎖很特別莺褒，是當(dāng)前調(diào)用這個(gè)方法的對(duì)象所屬的類（Class，而不再是由這個(gè)Class產(chǎn)生的某個(gè)具體對(duì)象了）雪情。

記得在《Effective Java》一書中看到過將 Foo.class和 P1.getClass()用于作同步鎖還不一樣遵岩，不能用P1.getClass()來(lái)達(dá)到鎖這個(gè)Class的目的。P1指的是由Foo類產(chǎn)生的對(duì)象。

可以推斷：如果一個(gè)類中定義了一個(gè)synchronized的static函數(shù)A尘执，也定義了一個(gè)synchronized 的instance函數(shù)B舍哄，那么這個(gè)類的同一對(duì)象Obj在多線程中分別訪問A和B兩個(gè)方法時(shí)，不會(huì)構(gòu)成同步誊锭，因?yàn)樗鼈兊逆i都不一樣表悬。A方法的鎖是Obj這個(gè)對(duì)象，而B的鎖是Obj所屬的那個(gè)Class丧靡。

?1蟆沫、線程同步的目的是為了保護(hù)多個(gè)線程反問一個(gè)資源時(shí)對(duì)資源的破壞。

?2窘行、線程同步方法是通過鎖來(lái)實(shí)現(xiàn)饥追，每個(gè)對(duì)象都有切僅有一個(gè)鎖，這個(gè)鎖與一個(gè)特定的對(duì)象關(guān)聯(lián)罐盔，線程一旦獲取了對(duì)象鎖但绕，其他訪問該對(duì)象的線程就無(wú)法再訪問該對(duì)象的其他非同步方法。

?3惶看、對(duì)于靜態(tài)同步方法捏顺，鎖是針對(duì)這個(gè)類的，鎖對(duì)象是該類的Class對(duì)象纬黎。靜態(tài)和非靜態(tài)方法的鎖互不干預(yù)幅骄。一個(gè)線程獲得鎖，當(dāng)在一個(gè)同步方法中訪問另外對(duì)象上的同步方法時(shí)本今，會(huì)獲取這兩個(gè)對(duì)象鎖拆座。

?4、對(duì)于同步冠息，要時(shí)刻清醒在哪個(gè)對(duì)象上同步挪凑，這是關(guān)鍵。

?5逛艰、編寫線程安全的類躏碳，需要時(shí)刻注意對(duì)多個(gè)線程競(jìng)爭(zhēng)訪問資源的邏輯和安全做出正確的判斷，對(duì)“原子”操作做出分析散怖，并保證原子操作期間別的線程無(wú)法訪問競(jìng)爭(zhēng)資源菇绵。

?6、當(dāng)多個(gè)線程等待一個(gè)對(duì)象鎖時(shí)镇眷，沒有獲取到鎖的線程將發(fā)生阻塞咬最。

?7、死鎖是線程間相互等待鎖鎖造成的欠动，在實(shí)際中發(fā)生的概率非常的小丹诀。真讓你寫個(gè)死鎖程序，不一定好使，呵呵铆遭。但是硝桩，一旦程序發(fā)生死鎖，程序?qū)⑺赖簟?/p>

九枚荣、線程數(shù)據(jù)傳遞

在傳統(tǒng)的同步開發(fā)模式下碗脊，當(dāng)我們調(diào)用一個(gè)函數(shù)時(shí)，通過這個(gè)函數(shù)的參數(shù)將數(shù)據(jù)傳入橄妆，并通過這個(gè)函數(shù)的返回值來(lái)返回最終的計(jì)算結(jié)果衙伶。但在多線程的異步開發(fā)模式下，數(shù)據(jù)的傳遞和返回和同步開發(fā)模式有很大的區(qū)別害碾。由于線程的運(yùn)行和結(jié)束是不可預(yù)料的矢劲，因此，在傳遞和返回?cái)?shù)據(jù)時(shí)就無(wú)法象函數(shù)一樣通過函數(shù)參數(shù)和return語(yǔ)句來(lái)返回?cái)?shù)據(jù)慌随。

9.1芬沉、通過構(gòu)造方法傳遞數(shù)據(jù)

在創(chuàng)建線程時(shí)，必須要建立一個(gè)Thread類的或其子類的實(shí)例阁猜。因此丸逸，我們不難想到在調(diào)用start方法之前通過線程類的構(gòu)造方法將數(shù)據(jù)傳入線程。并將傳入的數(shù)據(jù)使用類變量保存起來(lái)剃袍，以便線程使用(其實(shí)就是在run方法中使用)黄刚。下面的代碼演示了如何通過構(gòu)造方法來(lái)傳遞數(shù)據(jù)：

package mythread;

public class MyThread1 extends Thread

{

private String name;

public MyThread1(String name)

{

this.name = name;

}

public void run()

{

System.out.println("hello " + name);

}

public static void main(String[] args)

{

Thread thread = new MyThread1("world");

thread.start();

}

} 由于這種方法是在創(chuàng)建線程對(duì)象的同時(shí)傳遞數(shù)據(jù)的，因此民效，在線程運(yùn)行之前這些數(shù)據(jù)就就已經(jīng)到位了憔维，這樣就不會(huì)造成數(shù)據(jù)在線程運(yùn)行后才傳入的現(xiàn)象。如果要傳遞更復(fù)雜的數(shù)據(jù)畏邢，可以使用集合埋同、類等數(shù)據(jù)結(jié)構(gòu)。使用構(gòu)造方法來(lái)傳遞數(shù)據(jù)雖然比較安全棵红，但如果要傳遞的數(shù)據(jù)比較多時(shí)，就會(huì)造成很多不便咧栗。由于Java沒有默認(rèn)參數(shù)逆甜，要想實(shí)現(xiàn)類似默認(rèn)參數(shù)的效果，就得使用重載致板，這樣不但使構(gòu)造方法本身過于復(fù)雜交煞，又會(huì)使構(gòu)造方法在數(shù)量上大增。因此斟或，要想避免這種情況素征，就得通過類方法或類變量來(lái)傳遞數(shù)據(jù)。

9.2、通過變量和方法傳遞數(shù)據(jù)

向?qū)ο笾袀魅霐?shù)據(jù)一般有兩次機(jī)會(huì)御毅，第一次機(jī)會(huì)是在建立對(duì)象時(shí)通過構(gòu)造方法將數(shù)據(jù)傳入根欧，另外一次機(jī)會(huì)就是在類中定義一系列的public的方法或變量（也可稱之為字段）。然后在建立完對(duì)象后端蛆，通過對(duì)象實(shí)例逐個(gè)賦值凤粗。下面的代碼是對(duì)MyThread1類的改版，使用了一個(gè)setName方法來(lái)設(shè)置 name變量：

package mythread;

public class MyThread2 implements Runnable

{

private String name;

public void setName(String name)

{

this.name = name;

}

public void run()

{

System.out.println("hello " + name);

}

public static void main(String[] args)

{

MyThread2 myThread = new MyThread2();

myThread.setName("world");

Thread thread = new Thread(myThread);

thread.start();

}

} 9.3今豆、通過回調(diào)函數(shù)傳遞數(shù)據(jù)

上面討論的兩種向線程中傳遞數(shù)據(jù)的方法是最常用的嫌拣。但這兩種方法都是main方法中主動(dòng)將數(shù)據(jù)傳入線程類的。這對(duì)于線程來(lái)說呆躲，是被動(dòng)接收這些數(shù)據(jù)的异逐。然而，在有些應(yīng)用中需要在線程運(yùn)行的過程中動(dòng)態(tài)地獲取數(shù)據(jù)插掂，如在下面代碼的run方法中產(chǎn)生了3個(gè)隨機(jī)數(shù)灰瞻，然后通過Work類的process方法求這三個(gè)隨機(jī)數(shù)的和，并通過Data類的value將結(jié)果返回燥筷。從這個(gè)例子可以看出箩祥，在返回value之前，必須要得到三個(gè)隨機(jī)數(shù)肆氓。也就是說葛超，這個(gè) value是無(wú)法事先就傳入線程類的。

package mythread;

class Data

{

public int value = 0;

}

class Work

{

public void process(Data data, Integer numbers)

{

for (int n : numbers)

{

data.value += n;

}

}

}

public class MyThread3 extends Thread

{

private Work work;

public MyThread3(Work work)

{

this.work = work;

}

public void run()

{

java.util.Random random = new java.util.Random();

Data data = new Data();

int n1 = random.nextInt(1000);

int n2 = random.nextInt(2000);

int n3 = random.nextInt(3000);

work.process(data, n1, n2, n3); // 使用回調(diào)函數(shù)

System.out.println(String.valueOf(n1) + "+" + String.valueOf(n2) + "+"

+ String.valueOf(n3) + "=" + data.value);

}

public static void main(String[] args)

{

Thread thread = new MyThread3(new Work());

thread.start();

}

}