編寫具有多線程能力的程序經(jīng)常會用到的方法有：
run(),start(),wait(),notify(),notifyAll(),sleep(),yield(),join()
還有一個重要的關(guān)鍵字：synchronized
本文將對以上內(nèi)容進(jìn)行講解。

一：run()和start()
示例1：
public class ThreadTest extends Thread
{
public void run()
{
for(int i=0;i<10;i++)
{
System.out.print(" " + i);
}
}
public static void main(String[] args)
{
new ThreadTest().start();
new ThreadTest().start();
}
}
這是個簡單的多線程程序。run()和start()是大家都很熟悉的兩個方法。把希望并行處理的
代碼都放在run()中；stat()用于自動調(diào)用run()，這是JAVA 的內(nèi)在機(jī)制規(guī)定的。并且run()
的訪問控制符必須是public，返回值必須是void（這種說法不準(zhǔn)確，run()沒有返回值），run()
不帶參數(shù)。
這些規(guī)定想必大家都早已知道了，但你是否清楚為什么run 方法必須聲明成這樣的形式？這涉
及到JAVA 的方法覆蓋和重載的規(guī)定。這些內(nèi)容很重要，請讀者參考相關(guān)資料。

二：關(guān)鍵字synchronized
有了synchronized 關(guān)鍵字，多線程程序的運(yùn)行結(jié)果將變得可以控制。synchronized 關(guān)鍵
字用于保護(hù)共享數(shù)據(jù)。請大家注意"共享數(shù)據(jù)"，你一定要分清哪些數(shù)據(jù)是共享數(shù)據(jù)，JAVA 是面向
對象的程序設(shè)計(jì)語言，所以初學(xué)者在編寫多線程程序時，容易分不清哪些數(shù)據(jù)是共享數(shù)據(jù)。請看下
面的例子：
示例2：
public class ThreadTest implements Runnable
{ public synchronized void run()
{
for(int i=0;i<10;i++)
{
System.out.print(" " + i);
}
}
public static void main(String[] args)
{
Runnable r1 = new ThreadTest();
Runnable r2 = new ThreadTest();
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
t2.start();
}
}
在這個程序中，run()被加上了synchronized 關(guān)鍵字。在main 方法中創(chuàng)建了兩個線程。你
可能會認(rèn)為此程序的運(yùn)行結(jié)果一定為：0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9。但你
錯了！這個程序中synchronized 關(guān)鍵字保護(hù)的不是共享數(shù)據(jù)（其實(shí)在這個程序中synchronized
關(guān)鍵字沒有起到任何作用，此程序的運(yùn)行結(jié)果是不可預(yù)先確定的）。這個程序中的t1,t2 是兩個   對象（r1,r2）的線程。JAVA
是面向?qū)ο蟮某绦蛟O(shè)計(jì)語言，不同的對象的數(shù)據(jù)是不同的，r1,r2 有
各自的run()方法，而synchronized 使同一個對象的多個線程，在某個時刻只有其中的一個線程
可以訪問這個對象的synchronized 數(shù)據(jù)。每個對象都有一個"鎖標(biāo)志"，當(dāng)這個對象的一個線程
訪問這個對象的某個synchronized 數(shù)據(jù)時，這個對象的所有被synchronized 修飾的數(shù)據(jù)將被
上鎖（因?yàn)?鎖標(biāo)志"被當(dāng)前線程拿走了），只有當(dāng)前線程訪問完它要訪問的synchronized 數(shù)據(jù)
時，當(dāng)前線程才會釋放"鎖標(biāo)志"，這樣同一個對象的其它線程才有機(jī)會訪問synchronized 數(shù)據(jù)。
示例3：
public class ThreadTest implements Runnable
{
public synchronized void run()
{
for(int i=0;i<10;i++)
{
System.out.print(" " + i);
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start(); t2.start();
}
}
如果你運(yùn)行1000 次這個程序，它的輸出結(jié)果也一定每次都是：0 1 2 3 4 5 6 7 8 9 0 1
2 3 4 5 6 7 8 9。因?yàn)檫@里的synchronized 保護(hù)的是共享數(shù)據(jù)。t1,t2 是同一個對象（r）
的兩個線程，當(dāng)其中的一個線程（例如：t1）開始執(zhí)行run()方法時，由于run()受synchronized
保護(hù)，所以同一個對象的其他線程（t2）無法訪問synchronized 方法（run 方法）。只有當(dāng)t1
執(zhí)行完后t2 才有機(jī)會執(zhí)行。
示例4：
public class ThreadTest implements Runnable
{
public void run()
{
synchronized(this)
{
for(int i=0;i<10;i++)
{
System.out.print(" " + i);
}
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
}
}
這個程序與示例3 的運(yùn)行結(jié)果一樣。在可能的情況下，應(yīng)該把保護(hù)范圍縮到最小，可以用示例
4 的形式，this 代表"這個對象"。沒有必要把整個run()保護(hù)起來，run()中的代碼只有一個for 循環(huán)，所以只要保護(hù)for 循環(huán)就可以了。
示例5：
public class ThreadTest implements Runnable
{
public void run()
{
for(int k=0;k<5;k++)
{
System.out.println(Thread.currentThread().getName()
+ " : for loop : " + k); }
synchronized(this)
{
for(int k=0;k<5;k++)
{
System.out.println(Thread.currentThread().getName()
+ " : synchronized for loop : " + k);
}
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t1 = new Thread(r,"t1_name");
Thread t2 = new Thread(r,"t2_name");
t1.start();
t2.start();
}
}
運(yùn)行結(jié)果：
t1_name : for loop : 0
t1_name : for loop : 1
t1_name : for loop : 2
t2_name : for loop : 0
t1_name : for loop : 3
t2_name : for loop : 1
t1_name : for loop : 4
t2_name : for loop : 2
t1_name : synchronized for loop : 0
t2_name : for loop : 3
t1_name : synchronized for loop : 1
t2_name : for loop : 4
t1_name : synchronized for loop : 2
t1_name : synchronized for loop : 3
t1_name : synchronized for loop : 4
t2_name : synchronized for loop : 0
t2_name : synchronized for loop : 1
t2_name : synchronized for loop : 2
t2_name : synchronized for loop : 3
t2_name : synchronized for loop : 4
第一個for 循環(huán)沒有受synchronized 保護(hù)。對于第一個for 循環(huán)，t1,t2 可以同時訪問。
運(yùn)行結(jié)果表明t1 執(zhí)行到了k=2 時，t2 開始執(zhí)行了。t1 首先執(zhí)行完了第一個for 循環(huán)，此時t2
還沒有執(zhí)行完第一個for 循環(huán)（t2 剛執(zhí)行到k=2）。t1 開始執(zhí)行第二個for 循環(huán)，當(dāng)t1 的第二
個for 循環(huán)執(zhí)行到k=1 時，t2 的第一個for 循環(huán)執(zhí)行完了。t2 想開始執(zhí)行第二個for 循環(huán)，但
由于t1 首先執(zhí)行了第二個for 循環(huán)，這個對象的鎖標(biāo)志自然在t1 手中（synchronized 方法的
執(zhí)行權(quán)也就落到了t1 手中），在t1 沒執(zhí)行完第二個for 循環(huán)的時候，它是不會釋放鎖標(biāo)志的。所
以t2 必須等到t1 執(zhí)行完第二個for 循環(huán)后，它才可以執(zhí)行第二個for 循環(huán)。

三：sleep()
示例6：
public class ThreadTest implements Runnable
{
public void run()
{
for(int k=0;k<5;k++)
{
if(k == 2)
{
try
{
Thread.currentThread().sleep(5000);
}
catch(Exception e)
{}
}
System.out.print(" " + k);
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t = new Thread(r);
t.start();
}
}
sleep 方法會使當(dāng)前的線程暫停執(zhí)行一定時間（給其它線程運(yùn)行機(jī)會）。讀者可以運(yùn)行示例6，
看看結(jié)果就明白了。sleep 方法會拋出異常，必須提供捕獲代碼。
示例7：
public class ThreadTest implements Runnable
{
public void run()
{ for(int k=0;k<5;k++)
{
if(k == 2)
{
try
{
Thread.currentThread().sleep(5000);
}
catch(Exception e)
{}
}
System.out.println(Thread.currentThread().getName()
+ " : " + k);
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t1 = new Thread(r,"t1_name");
Thread t2 = new Thread(r,"t2_name");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
}
}
t1 被設(shè)置了最高的優(yōu)先級，t2 被設(shè)置了最低的優(yōu)先級。t1 不執(zhí)行完，t2 就沒有機(jī)會執(zhí)行。
但由于t1 在執(zhí)行的中途休息了5 秒中，這使得t2 就有機(jī)會執(zhí)行了。讀者可以運(yùn)行這個程序試試看。
示例8：
public class ThreadTest implements Runnable
{
public synchronized void run()
{
for(int k=0;k<5;k++)
{
if(k == 2)
{
try
{
Thread.currentThread().sleep(5000);
}
catch(Exception e)
{} }
System.out.println(Thread.currentThread().getName()
+ " : " + k);
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t1 = new Thread(r,"t1_name");
Thread t2 = new Thread(r,"t2_name");
t1.start();
t2.start();
}
}
請讀者首先運(yùn)行示例8 程序，從運(yùn)行結(jié)果上看：一個線程在sleep 的時候，并不會釋放這個對
象的鎖標(biāo)志。

四：join()
示例9：
public class ThreadTest implements Runnable
{
public static int a = 0;
public void run()
{
for(int k=0;k<5;k++)
{
a = a + 1;
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t = new Thread(r);
t.start();
System.out.println(a);
}
}
請問程序的輸出結(jié)果是5 嗎？答案是：有可能。其實(shí)你很難遇到輸出5 的時候，通常情況下都
不是5。這里不講解為什么輸出結(jié)果不是5，我要講的是：怎樣才能讓輸出結(jié)果為5！其實(shí)很簡單，
join()方法提供了這種功能。join()方法，它能夠使調(diào)用該方法的線程在此之前執(zhí)行完畢。
把示例9 的main()方法該成如下這樣： public static void main(String[] args) throws Exception
{
Runnable r = new ThreadTest();
Thread t = new Thread(r);
t.start();
t.join();
System.out.println(a);
}
這時，輸出結(jié)果肯定是5！join()方法會拋出異常，應(yīng)該提供捕獲代碼。或留給JDK 捕獲。
示例10：
public class ThreadTest implements Runnable
{
public void run()
{
for(int k=0;k<10;k++)
{
System.out.print(" " + k);
}
}
public static void main(String[] args) throws Exception
{
Runnable r = new ThreadTest();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t1.join();
t2.start();
}
}
運(yùn)行這個程序，看看結(jié)果是否與示例3 一樣？

五：yield()
yield()方法與sleep()方法相似，只是它不能由用戶指定線程暫停多長時間。按照SUN 的
說法：sleep
方法可以使低優(yōu)先級的線程得到執(zhí)行的機(jī)會，當(dāng)然也可以讓同優(yōu)先級和高優(yōu)先級的線程有執(zhí)行的機(jī)會。而yield()方法只能使同優(yōu)先級的線程有執(zhí)行的機(jī)會。
示例11：
public class ThreadTest implements Runnable
{
public void run()
{ for(int k=0;k<10;k++)
{
if(k == 5 && Thread.currentThread().getName().equals("t1"))
{
Thread.yield();
}
System.out.println(Thread.currentThread().getName()
+ " : " + k);
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t1 = new Thread(r,"t1");
Thread t2 = new Thread(r,"t2");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
}
}
輸出結(jié)果：
t1 : 0
t1 : 1
t1 : 2
t1 : 3
t1 : 4
t1 : 5
t1 : 6
t1 : 7
t1 : 8
t1 : 9
t2 : 0
t2 : 1
t2 : 2
t2 : 3
t2 : 4
t2 : 5
t2 : 6
t2 : 7
t2 : 8
t2 : 9
多次運(yùn)行這個程序，輸出也是一樣。這說明：yield()方法不會使不同優(yōu)先級的線程有執(zhí)行的
機(jī)會。

六：wait(),notify(),notifyAll()
首先說明：wait(),notify(),notifyAll()這些方法由java.lang.Object 類提供，而上面
講到的方法都是由java.lang.Thread 類提供（Thread 類實(shí)現(xiàn)了Runnable 接口）。
wait(),notify(),notifyAll()這三個方法用于協(xié)調(diào)多個線程對共享數(shù)據(jù)的存取，所以必
須在synchronized 語句塊內(nèi)使用這三個方法。先看下面了例子：
示例12：
public class ThreadTest implements Runnable
{
public static int shareVar = 0;
public synchronized void run()
{
if(shareVar == 0)
{
for(int i=0;i<10;i++)
{
shareVar++ ;
if(shareVar == 5)
{
try
{
this.wait();
}
catch(Exception e)
{}
}
}
}
if(shareVar != 0)
{
System.out.print(Thread.currentThread().getName());
System.out.println(" shareVar = " + shareVar);
this.notify();
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t1 = new Thread(r,"t1"); Thread t2 = new Thread(r,"t2");
t1.start();
t2.start();
}
}
運(yùn)行結(jié)果：
t2 shareVar = 5
t1 shareVar = 10
t1線程最先執(zhí)行。由于初始狀態(tài)下shareVar 為0，t1 將使shareVar 連續(xù)加1，當(dāng)shareVar
的值為5 時，t1 調(diào)用wait()方法，t1 將處于休息狀態(tài)，同時釋放鎖標(biāo)志。這時t2 得到了鎖標(biāo)志
開始執(zhí)行，shareVar 的值已經(jīng)變?yōu)?，所以t2 直接輸出shareVar 的值，然后再調(diào)用notify()
方法喚醒t1。t1 接著上次休息前的進(jìn)度繼續(xù)執(zhí)行，把shareVar 的值一直加到10，由于此刻
shareVar 的值不為0，所以t1 將輸出此刻shareVar 的值，然后再調(diào)用notify()方法，由于
此刻已經(jīng)沒有等待鎖標(biāo)志的線程，所以此調(diào)用語句不起任何作用。
這個程序簡單的示范了wait(),notify()的用法，讀者還需要在實(shí)踐中繼續(xù)摸索。

七：關(guān)于線程的補(bǔ)充
編寫一個具有多線程能力的程序可以繼承Thread 類，也可以實(shí)現(xiàn)Runnable 接口。在這兩個
方法中如何選擇呢？從面向?qū)ο蟮慕嵌瓤紤]，作者建議你實(shí)現(xiàn)Runnable 接口。有時你也必須實(shí)現(xiàn)
Runnable 接口，例如當(dāng)你編寫具有多線程能力的小應(yīng)用程序的時候。
線程的調(diào)度：
一個Thread 對象在它的生命周期中會處于各種不同的狀態(tài)，上圖形象地說明了這點(diǎn)。wa in
調(diào)用start()方法使線程處于可運(yùn)行狀態(tài)，這意味著它可以由JVM 調(diào)度并執(zhí)行。這并不意味
著線程就會立即運(yùn)行。
實(shí)際上，程序中的多個線程并不是同時執(zhí)行的。除非線程正在真正的多CPU 計(jì)算機(jī)系統(tǒng)上執(zhí)行，
否則線程使用單CPU 必須輪流執(zhí)行。但是，由于這發(fā)生的很快，我們常常認(rèn)為這些線程是同時執(zhí)行
的。
JAVA 運(yùn)行時系統(tǒng)的計(jì)劃調(diào)度程序是搶占性的。如果計(jì)劃調(diào)度程序正在運(yùn)行一個線程并且來了另
一個優(yōu)先級更高的線程，那么當(dāng)前正在執(zhí)行的線程就被暫時終止而讓更高優(yōu)先級的線程執(zhí)行。
JAVA 計(jì)劃調(diào)度程序不會為與當(dāng)前線程具有同樣優(yōu)先級的另一個線程去搶占當(dāng)前的線程。但是，
盡管計(jì)劃調(diào)度程序本身沒有時間片（即它沒有給相同優(yōu)先級的線程以執(zhí)行用的時間片），但以
Thread 類為基礎(chǔ)的線程的系統(tǒng)實(shí)現(xiàn)可能會支持時間片分配。這依賴具體的*作系統(tǒng)，Windows 與
UNIX 在這個問題上的支持不會完全一樣。
由于你不能肯定小應(yīng)用程序?qū)⑦\(yùn)行在什么*作系統(tǒng)上，因此你不應(yīng)該編寫出依賴時間片分配的
程序。就是說，應(yīng)該使用yield 方法以允許相同優(yōu)先級的線程有機(jī)會執(zhí)行而不是希望每一個線程都自動得到一段CPU 時間片。
Thread 類提供給你與系統(tǒng)無關(guān)的處理線程的機(jī)制。但是，線程的實(shí)際實(shí)現(xiàn)取決于JAVA 運(yùn)行
所在的*作系統(tǒng)。因此，線程化的程序確實(shí)是利用了支持線程的*作系統(tǒng)。
當(dāng)創(chuàng)建線程時，可以賦予它優(yōu)先級。它的優(yōu)先級越高，它就越能影響運(yùn)行系統(tǒng)。JAVA 運(yùn)行系統(tǒng)
使用一個負(fù)責(zé)在所有執(zhí)行JAVA 程序內(nèi)運(yùn)行所有存在的計(jì)劃調(diào)度程序。該計(jì)劃調(diào)度程序?qū)嶋H上使用
一個固定優(yōu)先級的算法來保證每個程序中的最高優(yōu)先級的線程得到CPU――允許最高優(yōu)先級的線程
在其它線程之前執(zhí)行。
對于在一個程序中有幾個相同優(yōu)先級的線程等待執(zhí)行的情況，該計(jì)劃調(diào)度程序循環(huán)地選擇它們，
當(dāng)進(jìn)行下一次選擇時選擇前面沒有執(zhí)行的線程，具有相同優(yōu)先級的所有的線程都受到平等的對待。
較低優(yōu)先級的線程在較高優(yōu)先級的線程已經(jīng)死亡或者進(jìn)入不可執(zhí)行狀態(tài)之后才能執(zhí)行。
繼續(xù)討論wait(),notify(),notifyAll()：
當(dāng)線程執(zhí)行了對一個特定對象的wait()調(diào)用時，那個線程被放到與那個對象相關(guān)的等待池中。
此外，調(diào)用wait()的線程自動釋放對象的鎖標(biāo)志。
可以調(diào)用不同的wait()：wait() 或wait(long timeout)
對一個特定對象執(zhí)行notify()調(diào)用時，將從對象的等待池中移走一個任意的線程，并放到鎖
標(biāo)志等待池中，那里的線程一直在等待，直到可以獲得對象的鎖標(biāo)志。notifyAll()方法將從對象
等待池中移走所有等待那個對象的線程并放到鎖標(biāo)志等待池中。只有鎖標(biāo)志等待池中的線程能獲取
對象的鎖標(biāo)志，鎖標(biāo)志允許線程從上次因調(diào)用wait()而中斷的地方開始繼續(xù)運(yùn)行。
在許多實(shí)現(xiàn)了wait()/notify()機(jī)制的系統(tǒng)中，醒來的線程必定是那個等待時間最長的線程。
然而，在Java 技術(shù)中，并不保證這點(diǎn)。
注意，不管是否有線程在等待，都可以調(diào)用notify()。如果對一個對象調(diào)用notify()方法，
而在這個對象的鎖標(biāo)志等待池中并沒有線程，那么notify()調(diào)用將不起任何作用。
在JAVA 中，多線程是一個神奇的主題。之所以說它"神奇"，是因?yàn)槎嗑€程程序的運(yùn)行結(jié)果不
可預(yù)測，但我們又可以通過某些方法控制多線程程序的執(zhí)行。要想靈活使用多線程，讀者還需要大
量實(shí)踐。
另外，從JDK 1.2 開始，SUN 就不建議使用resume(),stop(),suspend()了。

轉(zhuǎn)http://vegetable318.bokee.com