林炳文Evankaka原創作品。轉載請注明出處http://blog.csdn.net/evankaka
目錄(?)[-]
- 一擴充javalangThread類
- 二實作javalangRunnable接口
- 三Thread和Runnable的差別
- 四線程狀态轉換
- 五線程排程
- 六常用函數說明
- 使用方式
- 為什麼要用join方法
- 七常見線程名詞解釋
- 八線程同步
- 九線程資料傳遞
本文主要講了java中多線程的使用方法、線程同步、線程資料傳遞、線程狀态及相應的一些線程函數用法、概述等。
首先講一下程序和線程的差別：
程序：每個程序都有獨立的代碼和資料空間（程序上下文），程序間的切換會有較大的開銷，一個程序包含1--n個線程。
線程：同一類線程共享代碼和資料空間，每個線程有獨立的運作棧和程式計數器(PC)，線程切換開銷小。
線程和程序一樣分為五個階段：建立、就緒、運作、阻塞、終止。
多程序是指作業系統能同時運作多個任務（程式）。
多線程是指在同一程式中有多個順序流在執行。
在java中要想實作多線程，有兩種手段，一種是繼續Thread類，另外一種是實作Runable接口。
一、擴充java.lang.Thread類
package com.multithread.learning;
/**
*@functon 多線程學習
*@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 + "運作 : " + 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運作 : 0
B運作 : 0
A運作 : 1
A運作 : 2
A運作 : 3
A運作 : 4
B運作 : 1
B運作 : 2
B運作 : 3
B運作 : 4
再運作一下：
A運作 : 0
B運作 : 0
B運作 : 1
B運作 : 2
B運作 : 3
B運作 : 4
A運作 : 1
A運作 : 2
A運作 : 3
A運作 : 4
說明： 程式啟動運作main時候，java虛拟機啟動一個程序，主線程main在main()調用時候被建立。随着調用MitiSay的兩個對象的start方法，另外兩個線程也啟動了，這樣，整個應用就在多線程下運作。 注意：start()方法的調用後并不是立即執行多線程代碼，而是使得該線程變為可運作态（Runnable），什麼時候運作是由作業系統決定的。 從程式運作的結果可以發現，多線程程式是亂序執行。是以，隻有亂序執行的代碼才有必要設計為多線程。 Thread.sleep()方法調用目的是不讓目前線程獨自霸占該程序所擷取的CPU資源，以留出一定時間給其他線程執行的機會。 實際上所有的多線程代碼執行順序都是不确定的，每次執行的結果都是随機的。
但是start方法重複調用的話，會出現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運作 : 0
A運作 : 1
A運作 : 2
A運作 : 3
A運作 : 4
二、實作java.lang.Runnable接口
/**
*@functon 多線程學習
*@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 + "運作 : " + 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運作 : 0
D運作 : 0
D運作 : 1
C運作 : 1
D運作 : 2
C運作 : 2
D運作 : 3
C運作 : 3
D運作 : 4
C運作 : 4
說明： Thread2類通過實作Runnable接口，使得該類有了多線程類的特征。run（）方法是多線程程式的一個約定。所有的多線程代碼都在run方法裡面。Thread類實際上也是實作了Runnable接口的類。 在啟動的多線程的時候，需要先通過Thread類的構造方法Thread(Runnable target) 構造出對象，然後調用Thread對象的start()方法來運作多線程代碼。 實際上所有的多線程代碼都是通過運作Thread的start()方法來運作的。是以，不管是擴充Thread類還是實作Runnable接口來實作多線程，最終還是通過Thread的對象的API來控制線程的，熟悉Thread類的API是進行多線程程式設計的基礎。
三、Thread和Runnable的差別
如果一個類繼承Thread，則不适合資源共享。但是如果實作了Runable接口的話，則很容易的實作資源共享。
package com.multithread.learning;
/**
*@functon 多線程學習,繼承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 + "運作 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運作 count= 5
A運作 count= 5
B運作 count= 4
B運作 count= 3
B運作 count= 2
B運作 count= 1
A運作 count= 4
A運作 count= 3
A運作 count= 2
A運作 count= 1
從上面可以看出，不同的線程之間count是不同的，這對于賣票系統來說就會有很大的問題，當然，這裡可以用同步來作。這裡我們用Runnable來做下看看
/**
*@functon 多線程學習 繼承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() + "運作 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();//同一個mt，但是在Thread中就不可以，如果用同一個執行個體化對象mt，就會出現異常
new Thread(my, "D").start();
new Thread(my, "E").start();
}
}
輸出：
C運作 count= 15
D運作 count= 14
E運作 count= 13
D運作 count= 12
D運作 count= 10
D運作 count= 9
D運作 count= 8
C運作 count= 11
E運作 count= 12
C運作 count= 7
E運作 count= 6
C運作 count= 5
E運作 count= 4
C運作 count= 3
E運作 count= 2
這裡要注意每個線程都是用同一個執行個體化對象，如果不是同一個，效果就和上面的一樣了！
總結：
實作Runnable接口比繼承Thread類所具有的優勢：
1）：适合多個相同的程式代碼的線程去處理同一個資源
2）：可以避免java中的單繼承的限制
3）：增加程式的健壯性，代碼可以被多個線程共享，代碼和資料獨立
提醒一下大家：main方法其實也是一個線程。在java中是以的線程都是同時啟動的，至于什麼時候，哪個先執行，完全看誰先得到CPU的資源。
在java中，每次程式運作至少啟動2個線程。一個是main線程，一個是垃圾收集線程。因為每當使用java指令執行一個類的時候，實際上都會啟動一個ＪＶＭ，每一個ｊＶＭ實習在就是在作業系統中啟動了一個程序。
四、線程狀态轉換
1、建立狀态（New）：新建立了一個線程對象。 2、就緒狀态（Runnable）：線程對象建立後，其他線程調用了該對象的start()方法。該狀态的線程位于可運作線程池中，變得可運作，等待擷取CPU的使用權。 3、運作狀态（Running）：就緒狀态的線程擷取了CPU，執行程式代碼。 4、阻塞狀态（Blocked）：阻塞狀态是線程因為某種原因放棄CPU使用權，暫時停止運作。直到線程進入就緒狀态，才有機會轉到運作狀态。阻塞的情況分三種： （一）、等待阻塞：運作的線程執行wait()方法，JVM會把該線程放入等待池中。 （二）、同步阻塞：運作的線程在擷取對象的同步鎖時，若該同步鎖被别的線程占用，則JVM會把該線程放入鎖池中。 （三）、其他阻塞：運作的線程執行sleep()或join()方法，或者發出了I/O請求時，JVM會把該線程置為阻塞狀态。當sleep()狀态逾時、join()等待線程終止或者逾時、或者I/O處理完畢時，線程重新轉入就緒狀态。 5、死亡狀态（Dead）：線程執行完了或者因異常退出了run()方法，該線程結束生命周期。
五、線程排程
線程的排程
1、調整線程優先級：Java線程有優先級，優先級高的線程會獲得較多的運作機會。 Java線程的優先級用整數表示，取值範圍是1~10，Thread類有以下三個靜态常量： static int MAX_PRIORITY 線程可以具有的最高優先級，取值為10。 static int MIN_PRIORITY 線程可以具有的最低優先級，取值為1。 static int NORM_PRIORITY 配置設定給線程的預設優先級，取值為5。 Thread類的setPriority()和getPriority()方法分别用來設定和擷取線程的優先級。 每個線程都有預設的優先級。主線程的預設優先級為Thread.NORM_PRIORITY。 線程的優先級有繼承關系，比如A線程中建立了B線程，那麼B将和A具有相同的優先級。 JVM提供了10個線程優先級，但與常見的作業系統都不能很好的映射。如果希望程式能移植到各個作業系統中，應該僅僅使用Thread類有以下三個靜态常量作為優先級，這樣能保證同樣的優先級采用了同樣的排程方式。 2、線程睡眠：Thread.sleep(long millis)方法，使線程轉到阻塞狀态。millis參數設定睡眠的時間，以毫秒為機關。當睡眠結束後，就轉為就緒（Runnable）狀态。sleep()平台移植性好。 3、線程等待：Object類中的wait()方法，導緻目前的線程等待，直到其他線程調用此對象的 notify() 方法或 notifyAll() 喚醒方法。這個兩個喚醒方法也是Object類中的方法，行為等價于調用 wait(0) 一樣。 4、線程讓步：Thread.yield() 方法，暫停目前正在執行的線程對象，把執行機會讓給相同或者更高優先級的線程。 5、線程加入：join()方法，等待其他線程終止。在目前線程中調用另一個線程的join()方法，則目前線程轉入阻塞狀态，直到另一個程序運作結束，目前線程再由阻塞轉為就緒狀态。 6、線程喚醒：Object類中的notify()方法，喚醒在此對象螢幕上等待的單個線程。如果所有線程都在此對象上等待，則會選擇喚醒其中一個線程。選擇是任意性的，并在對實作做出決定時發生。線程通過調用其中一個 wait 方法，在對象的螢幕上等待。 直到目前的線程放棄此對象上的鎖定，才能繼續執行被喚醒的線程。被喚醒的線程将以正常方式與在該對象上主動同步的其他所有線程進行競争；例如，喚醒的線程在作為鎖定此對象的下一個線程方面沒有可靠的特權或劣勢。類似的方法還有一個notifyAll()，喚醒在此對象螢幕上等待的所有線程。 注意：Thread中suspend()和resume()兩個方法在JDK1.5中已經廢除，不再介紹。因為有死鎖傾向。
六、常用函數說明
①sleep(long millis): 在指定的毫秒數内讓目前正在執行的線程休眠（暫停執行）
②join():指等待t線程終止。
使用方式。
join是Thread類的一個方法，啟動線程後直接調用，即join()的作用是：“等待該線程終止”，這裡需要了解的就是該線程是指的主線程等待子線程的終止。也就是在子線程調用了join()方法後面的代碼，隻有等到子線程結束了才能執行。
Thread t = new AThread(); t.start(); t.join();
為什麼要用join()方法
在很多情況下，主線程生成并起動了子線程，如果子線程裡要進行大量的耗時的運算，主線程往往将于子線程之前結束，但是如果主線程處理完其他的事務後，需要用到子線程的處理結果，也就是主線程需要等待子線程執行完成之後再結束，這個時候就要用到join()方法了。
不加join。
/**
*@functon 多線程學習,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() + " 線程運作開始!");
for (int i = 0; i < 5; i++) {
System.out.println("子線程"+name + "運作 : " + i);
try {
sleep((int) Math.random() * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + " 線程運作結束!");
}
}
public class Main {
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName()+"主線程運作開始!");
Thread1 mTh1=new Thread1("A");
Thread1 mTh2=new Thread1("B");
mTh1.start();
mTh2.start();
System.out.println(Thread.currentThread().getName()+ "主線程運作結束!");
}
}
輸出結果：
main主線程運作開始!
main主線程運作結束!
B 線程運作開始!
子線程B運作 : 0
A 線程運作開始!
子線程A運作 : 0
子線程B運作 : 1
子線程A運作 : 1
子線程A運作 : 2
子線程A運作 : 3
子線程A運作 : 4
A 線程運作結束!
子線程B運作 : 2
子線程B運作 : 3
子線程B運作 : 4
B 線程運作結束!
發現主線程比子線程早結束
加join
public class Main {
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName()+"主線程運作開始!");
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()+ "主線程運作結束!");
}
}
運作結果：
main主線程運作開始!
A 線程運作開始!
子線程A運作 : 0
B 線程運作開始!
子線程B運作 : 0
子線程A運作 : 1
子線程B運作 : 1
子線程A運作 : 2
子線程B運作 : 2
子線程A運作 : 3
子線程B運作 : 3
子線程A運作 : 4
子線程B運作 : 4
A 線程運作結束!
主線程一定會等子線程都結束了才結束
③yield():暫停目前正在執行的線程對象，并執行其他線程。
Thread.yield()方法作用是：暫停目前正在執行的線程對象，并執行其他線程。 yield()應該做的是讓目前運作線程回到可運作狀态，以允許具有相同優先級的其他線程獲得運作機會。是以，使用yield()的目的是讓相同優先級的線程之間能适當的輪轉執行。但是，實際中無法保證yield()達到讓步目的，因為讓步的線程還有可能被線程排程程式再次選中。 結論：yield()從未導緻線程轉到等待/睡眠/阻塞狀态。在大多數情況下，yield()将導緻線程從運作狀态轉到可運作狀态，但有可能沒有效果。可看上面的圖。
/**
*@functon 多線程學習 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);
// 當i為30時，該線程就會把CPU時間讓掉，讓其他或者自己的線程執行（也就是誰先搶到誰執行）
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();
}
}
運作結果：
第一種情況：李四（線程）當執行到30時會CPU時間讓掉，這時張三（線程）搶到CPU時間并執行。
第二種情況：李四（線程）當執行到30時會CPU時間讓掉，這時李四（線程）搶到CPU時間并執行。
sleep()和yield()的差別
sleep()和yield()的差別):sleep()使目前線程進入停滞狀态，是以執行sleep()的線程在指定的時間内肯定不會被執行；yield()隻是使目前線程重新回到可執行狀态，是以執行yield()的線程有可能在進入到可執行狀态後馬上又被執行。
sleep 方法使目前運作中的線程睡眼一段時間，進入不可運作狀态，這段時間的長短是由程式設定的，yield 方法使目前線程讓出 CPU 占有權，但讓出的時間是不可設定的。實際上，yield()方法對應了如下操作：先檢測目前是否有相同優先級的線程處于同可運作狀态，如有，則把 CPU 的占有權交給此線程，否則，繼續運作原來的線程。是以yield()方法稱為“退讓”，它把運作機會讓給了同等優先級的其他線程
另外，sleep 方法允許較低優先級的線程獲得運作機會，但 yield() 方法執行時，目前線程仍處在可運作狀态，是以，不可能讓出較低優先級的線程些時獲得 CPU 占有權。在一個運作系統中，如果較高優先級的線程沒有調用 sleep 方法，又沒有受到 I\O 阻塞，那麼，較低優先級線程隻能等待所有較高優先級的線程運作結束，才有機會運作。
④setPriority(): 更改線程的優先級。
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():中斷某個線程，這種結束方式比較粗暴，如果t線程打開了某個資源還沒來得及關閉也就是run方法還沒有執行完就強制結束線程，會導緻資源無法關閉
要想結束程序最好的辦法就是用sleep()函數的例子程式裡那樣，線上程類裡面用以個boolean型變量來控制run()方法什麼時候結束，run()方法一結束，該線程也就結束了。
⑥wait()
Obj.wait()，與Obj.notify()必須要與synchronized(Obj)一起使用，也就是wait,與notify是針對已經擷取了Obj鎖進行操作，從文法角度來說就是Obj.wait(),Obj.notify必須在synchronized(Obj){...}語句塊内。從功能上來說wait就是說線程在擷取對象鎖後，主動釋放對象鎖，同時本線程休眠。直到有其它線程調用對象的notify()喚醒該線程，才能繼續擷取對象鎖，并繼續執行。相應的notify()就是對對象鎖的喚醒操作。但有一點需要注意的是notify()調用後，并不是馬上就釋放對象鎖的，而是在相應的synchronized(){}語句塊執行結束，自動釋放鎖後，JVM會在wait()對象鎖的線程中随機選取一線程，賦予其對象鎖，喚醒線程，繼續執行。這樣就提供了線上程間同步、喚醒的操作。Thread.sleep()與Object.wait()二者都可以暫停目前線程，釋放CPU控制權，主要的差別在于Object.wait()在釋放CPU同時，釋放了對象鎖的控制。
單單在概念上了解清楚了還不夠，需要在實際的例子中進行測試才能更好的了解。對Object.wait()，Object.notify()的應用最經典的例子，應該是三線程列印ABC的問題了吧，這是一道比較經典的面試題，題目要求如下：
建立三個線程，A線程列印10次A，B線程列印10次B,C線程列印10次C，要求線程同時運作，交替列印10次ABC。這個問題用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執行
new Thread(pb).start();
Thread.sleep(100);
new Thread(pc).start();
Thread.sleep(100);
}
}
輸出結果：
ABCABCABCABCABCABCABCABCABCABC
先來解釋一下其整體思路，從大的方向上來講，該問題為三線程間的同步喚醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循環執行三個線程。為了控制線程執行的順序，那麼就必須要确定喚醒、等待的順序，是以每一個線程必須同時持有兩個對象鎖，才能繼續執行。一個對象鎖是prev，就是前一個線程所持有的對象鎖。還有一個就是自身對象鎖。主要的思想就是，為了控制執行的順序，必須要先持有prev鎖，也就前一個線程要釋放自身對象鎖，再去申請自身對象鎖，兩者兼備時列印，之後首先調用self.notify()釋放自身對象鎖，喚醒下一個等待線程，再調用prev.wait()釋放prev對象鎖，終止目前線程，等待循環結束後再次被喚醒。運作上述代碼，可以發現三個線程循環列印ABC，共10次。程式運作的主要過程就是A線程最先運作，持有C,A對象鎖，後釋放A,C鎖，喚醒B。線程B等待A鎖，再申請B鎖，後列印B，再釋放B，A鎖，喚醒C，線程C等待B鎖，再申請C鎖，後列印C，再釋放C,B鎖，喚醒A。看起來似乎沒什麼問題，但如果你仔細想一下，就會發現有問題，就是初始條件，三個線程按照A,B,C的順序來啟動，按照前面的思考，A喚醒B，B喚醒C，C再喚醒A。但是這種假設依賴于JVM中線程排程、執行的順序。
wait和sleep差別
共同點：
1. 他們都是在多線程的環境下，都可以在程式的調用處阻塞指定的毫秒數，并傳回。
2. wait()和sleep()都可以通過interrupt()方法 打斷線程的暫停狀态 ，進而使線程立刻抛出InterruptedException。
如果線程A希望立即結束線程B，則可以對線程B對應的Thread執行個體調用interrupt方法。如果此刻線程B正在wait/sleep /join，則線程B會立刻抛出InterruptedException，在catch() {} 中直接return即可安全地結束線程。
需要注意的是，InterruptedException是線程自己從内部抛出的，并不是interrupt()方法抛出的。對某一線程調用 interrupt()時，如果該線程正在執行普通的代碼，那麼該線程根本就不會抛出InterruptedException。但是，一旦該線程進入到 wait()/sleep()/join()後，就會立刻抛出InterruptedException 。
不同點：
1. Thread類的方法：sleep(),yield()等
Object的方法：wait()和notify()等
2. 每個對象都有一個鎖來控制同步通路。Synchronized關鍵字可以和對象的鎖互動，來實作線程的同步。
sleep方法沒有釋放鎖，而wait方法釋放了鎖，使得其他線程可以使用同步控制塊或者方法。
3. wait，notify和notifyAll隻能在同步控制方法或者同步控制塊裡面使用，而sleep可以在任何地方使用
4. sleep必須捕獲異常，而wait，notify和notifyAll不需要捕獲異常
是以sleep()和wait()方法的最大差別是：
sleep()睡眠時，保持對象鎖，仍然占有該鎖；
而wait()睡眠時，釋放對象鎖。
但是wait()和sleep()都可以通過interrupt()方法打斷線程的暫停狀态，進而使線程立刻抛出InterruptedException（但不建議使用該方法）。
sleep（）方法
sleep()使目前線程進入停滞狀态（阻塞目前線程），讓出CUP的使用、目的是不讓目前線程獨自霸占該程序所獲的CPU資源，以留一定時間給其他線程執行的機會;
sleep()是Thread類的Static(靜态)的方法；是以他不能改變對象的機鎖，是以當在一個Synchronized塊中調用Sleep()方法是，線程雖然休眠了，但是對象的機鎖并木有被釋放，其他線程無法通路這個對象（即使睡着也持有對象鎖）。
在sleep()休眠時間期滿後，該線程不一定會立即執行，這是因為其它線程可能正在運作而且沒有被排程為放棄執行，除非此線程具有更高的優先級。
wait（）方法
wait()方法是Object類裡的方法；當一個線程執行到wait()方法時，它就進入到一個和該對象相關的等待池中，同時失去（釋放）了對象的機鎖（暫時失去機鎖，wait(long timeout)逾時時間到後還需要返還對象鎖）；其他線程可以通路；
wait()使用notify或者notifyAlll或者指定睡眠時間來喚醒目前等待池中的線程。
wiat()必須放在synchronized block中，否則會在program runtime時扔出”java.lang.IllegalMonitorStateException“異常。
七、常見線程名詞解釋
主線程：JVM調用程式main()所産生的線程。 目前線程：這個是容易混淆的概念。一般指通過Thread.currentThread()來擷取的程序。 背景線程：指為其他線程提供服務的線程，也稱為守護線程。JVM的垃圾回收線程就是一個背景線程。 使用者線程和守護線程的差別在于，是否等待主線程依賴于主線程結束而結束 前台線程：是指接受背景線程服務的線程，其實前台背景線程是聯系在一起，就像傀儡和幕後操縱者一樣的關系。傀儡是前台線程、幕後操縱者是背景線程。由前台線程建立的線程預設也是前台線程。可以通過isDaemon()和setDaemon()方法來判斷和設定一個線程是否為背景線程。 線程類的一些常用方法：
sleep(): 強迫一個線程睡眠Ｎ毫秒。
isAlive(): 判斷一個線程是否存活。
join(): 等待線程終止。
activeCount(): 程式中活躍的線程數。
enumerate(): 枚舉程式中的線程。
currentThread(): 得到目前線程。
isDaemon(): 一個線程是否為守護線程。
setDaemon(): 設定一個線程為守護線程。(使用者線程和守護線程的差別在于，是否等待主線程依賴于主線程結束而結束)
setName(): 為線程設定一個名稱。
wait(): 強迫一個線程等待。
notify(): 通知一個線程繼續運作。
setPriority(): 設定一個線程的優先級。
八、線程同步
1、synchronized關鍵字的作用域有二種：
1）是某個對象執行個體内，synchronized aMethod(){}可以防止多個線程同時通路這個對象的synchronized方法（如果一個對象有多個synchronized方法，隻要一個線程通路了其中的一個synchronized方法，其它線程不能同時通路這個對象中任何一個synchronized方法）。這時，不同的對象執行個體的synchronized方法是不相幹擾的。也就是說，其它線程照樣可以同時通路相同類的另一個對象執行個體中的synchronized方法；
2）是某個類的範圍，synchronized static aStaticMethod{}防止多個線程同時通路這個類中的synchronized static 方法。它可以對類的所有對象執行個體起作用。
2、除了方法前用synchronized關鍵字，synchronized關鍵字還可以用于方法中的某個區塊中，表示隻對這個區塊的資源實行互斥通路。用法是: synchronized(this){}，它的作用域是目前對象；
3、synchronized關鍵字是不能繼承的，也就是說，基類的方法synchronized f(){} 在繼承類中并不自動是synchronized f(){}，而是變成了f(){}。繼承類需要你顯式的指定它的某個方法為synchronized方法；
Java對多線程的支援與同步機制深受大家的喜愛，似乎看起來使用了synchronized關鍵字就可以輕松地解決多線程共享資料同步問題。到底如何？――還得對synchronized關鍵字的作用進行深入了解才可定論。
總的說來，synchronized關鍵字可以作為函數的修飾符，也可作為函數内的語句，也就是平時說的同步方法和同步語句塊。如果再細的分類，synchronized可作用于instance變量、object reference（對象引用）、static函數和class literals(類名稱字面常量)身上。
在進一步闡述之前，我們需要明确幾點：
A．無論synchronized關鍵字加在方法上還是對象上，它取得的鎖都是對象，而不是把一段代碼或函數當作鎖――而且同步方法很可能還會被其他線程的對象通路。
B．每個對象隻有一個鎖（lock）與之相關聯。
C．實作同步是要很大的系統開銷作為代價的，甚至可能造成死鎖，是以盡量避免無謂的同步控制。
接着來讨論synchronized用到不同地方對代碼産生的影響：
假設P1、P2是同一個類的不同對象，這個類中定義了以下幾種情況的同步塊或同步方法，P1、P2就都可以調用它們。
1． 把synchronized當作函數修飾符時，示例代碼如下：
Public synchronized void methodAAA()
{
//….
}
這也就是同步方法，那這時synchronized鎖定的是哪個對象呢？它鎖定的是調用這個同步方法對象。也就是說，當一個對象P1在不同的線程中執行這個同步方法時，它們之間會形成互斥，達到同步的效果。但是這個對象所屬的Class所産生的另一對象P2卻可以任意調用這個被加了synchronized關鍵字的方法。
上邊的示例代碼等同于如下代碼：
public void methodAAA()
{
synchronized (this) // (1)
{
//…..
}
}
(1)處的this指的是什麼呢？它指的就是調用這個方法的對象，如P1。可見同步方法實質是将synchronized作用于object reference。――那個拿到了P1對象鎖的線程，才可以調用P1的同步方法，而對P2而言，P1這個鎖與它毫不相幹，程式也可能在這種情形下擺脫同步機制的控制，造成資料混亂：（
2．同步塊，示例代碼如下：
public void method3(SomeObject so)
{
synchronized(so)
{
//…..
}
}
這時，鎖就是so這個對象，誰拿到這個鎖誰就可以運作它所控制的那段代碼。當有一個明确的對象作為鎖時，就可以這樣寫程式，但當沒有明确的對象作為鎖，隻是想讓一段代碼同步時，可以建立一個特殊的instance變量（它得是一個對象）來充當鎖：
class Foo implements Runnable
{
private byte[] lock = new byte[0]; // 特殊的instance變量
Public void methodA()
{
synchronized(lock) { //… }
}
//…..
}
注：零長度的byte數組對象建立起來将比任何對象都經濟――檢視編譯後的位元組碼：生成零長度的byte[]對象隻需3條操作碼，而Object lock = new Object()則需要7行操作碼。
3．将synchronized作用于static 函數，示例代碼如下：
Class Foo
{
public synchronized static void methodAAA() // 同步的static 函數
{
//….
}
public void methodBBB()
{
synchronized(Foo.class) // class literal(類名稱字面常量)
}
}
代碼中的methodBBB()方法是把class literal作為鎖的情況，它和同步的static函數産生的效果是一樣的，取得的鎖很特别，是目前調用這個方法的對象所屬的類（Class，而不再是由這個Class産生的某個具體對象了）。
記得在《Effective Java》一書中看到過将 Foo.class和 P1.getClass()用于作同步鎖還不一樣，不能用P1.getClass()來達到鎖這個Class的目的。P1指的是由Foo類産生的對象。
可以推斷：如果一個類中定義了一個synchronized的static函數A，也定義了一個synchronized 的instance函數B，那麼這個類的同一對象Obj在多線程中分别通路A和B兩個方法時，不會構成同步，因為它們的鎖都不一樣。A方法的鎖是Obj這個對象，而B的鎖是Obj所屬的那個Class。
1、線程同步的目的是為了保護多個線程反問一個資源時對資源的破壞。
2、線程同步方法是通過鎖來實作，每個對象都有切僅有一個鎖，這個鎖與一個特定的對象關聯，線程一旦擷取了對象鎖，其他通路該對象的線程就無法再通路該對象的其他非同步方法。
3、對于靜态同步方法，鎖是針對這個類的，鎖對象是該類的Class對象。靜态和非靜态方法的鎖互不幹預。一個線程獲得鎖，當在一個同步方法中通路另外對象上的同步方法時，會擷取這兩個對象鎖。
4、對于同步，要時刻清醒在哪個對象上同步，這是關鍵。
5、編寫線程安全的類，需要時刻注意對多個線程競争通路資源的邏輯和安全做出正确的判斷，對“原子”操作做出分析，并保證原子操作期間别的線程無法通路競争資源。
6、當多個線程等待一個對象鎖時，沒有擷取到鎖的線程将發生阻塞。
7、死鎖是線程間互相等待鎖鎖造成的，在實際中發生的機率非常的小。真讓你寫個死鎖程式，不一定好使，呵呵。但是，一旦程式發生死鎖，程式将死掉。
九、線程資料傳遞
在傳統的同步開發模式下，當我們調用一個函數時，通過這個函數的參數将資料傳入，并通過這個函數的傳回值來傳回最終的計算結果。但在多線程的異步開發模式下，資料的傳遞和傳回和同步開發模式有很大的差別。由于線程的運作和結束是不可預料的，是以，在傳遞和傳回資料時就無法象函數一樣通過函數參數和return語句來傳回資料。
9.1、通過構造方法傳遞資料
在建立線程時，必須要建立一個Thread類的或其子類的執行個體。是以，我們不難想到在調用start方法之前通過線程類的構造方法将資料傳入線程。并将傳入的資料使用類變量儲存起來，以便線程使用(其實就是在run方法中使用)。下面的代碼示範了如何通過構造方法來傳遞資料：
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();
}
}
由于這種方法是在建立線程對象的同時傳遞資料的，是以，線上程運作之前這些資料就就已經到位了，這樣就不會造成資料線上程運作後才傳入的現象。如果要傳遞更複雜的資料，可以使用集合、類等資料結構。使用構造方法來傳遞資料雖然比較安全，但如果要傳遞的資料比較多時，就會造成很多不便。由于Java沒有預設參數，要想實作類似預設參數的效果，就得使用重載，這樣不但使構造方法本身過于複雜，又會使構造方法在數量上大增。是以，要想避免這種情況，就得通過類方法或類變量來傳遞資料。
9.2、通過變量和方法傳遞資料
向對象中傳入資料一般有兩次機會，第一次機會是在建立對象時通過構造方法将資料傳入，另外一次機會就是在類中定義一系列的public的方法或變量（也可稱之為字段）。然後在建立完對象後，通過對象執行個體逐個指派。下面的代碼是對MyThread1類的改版，使用了一個setName方法來設定 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、通過回調函數傳遞資料
上面讨論的兩種向線程中傳遞資料的方法是最常用的。但這兩種方法都是main方法中主動将資料傳入線程類的。這對于線程來說，是被動接收這些資料的。然而，在有些應用中需要線上程運作的過程中動态地擷取資料，如在下面代碼的run方法中産生了3個随機數，然後通過Work類的process方法求這三個随機數的和，并通過Data類的value将結果傳回。從這個例子可以看出，在傳回value之前，必須要得到三個随機數。也就是說，這個 value是無法事先就傳入線程類的。
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); // 使用回調函數
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();
}
}
林炳文Evankaka原創作品。轉載請注明出處http://blog.csdn.net/evankaka
Java多線程學習（吐血超詳細總結）
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)