一個理解wait()與notify()的例子
原文鏈接：http://blog.csdn.net/xm4014/archive/2003/01/28/14714.aspx
下面是我原來在CSDN論壇上看到的一個貼子，涉及到同步,wait(),notify()等概念的理解，我試着根據原來的一些回覆和Think in Java上的相關概念將wait()和notify()這兩個方法剖析了一下，歡迎指教.
問題如下：
file://分析這段程序，並解釋一下，着重講講synchronized、wait(),notify 謝謝！
class ThreadA
{
public static void main(String[] args)
{
ThreadB b=new ThreadB();
b.start();
System.out.println("b is start....");
synchronized(b)//括號裏的b是什麼意思,起什麼作用?
{
try
{
System.out.println("Waiting for b to complete...");
b.wait();//這一句是什麼意思，究竟讓誰wait?
System.out.println("Completed.Now back to main thread");
}catch (InterruptedException e){}
}
System.out.println("Total is :"+b.total);
}
}
class ThreadB extends Thread
{
int total;
public void run()
{
synchronized(this)
{
System.out.println("ThreadB is running..");
for (int i=0;i<100;i++ )
{
total +=i;
System.out.println("total is "+total);
}
notify();
}
}
}
要分析這個程序,首先要理解notify()和wait(),爲什麼在前幾天紀錄線程的時候沒有紀錄這兩個方法呢,因爲這兩個方法本來就不屬於 Thread類,而是屬於最底層的object基礎類的,也就是說不光是Thread，每個對象都有notify和wait的功能，爲什麼？因爲他們是用來操縱鎖的,而每個對象都有鎖,鎖是每個對象的基礎,既然鎖是基礎的,那麼操縱鎖的方法當然也是最基礎了.
再往下看之前呢,首先最好複習一下Think in Java的14.3.1中第3部分內容：等待和通知,也就是wait()和notify了.
按照Think in Java中的解釋:"wait()允許我們將線程置入“睡眠”狀態，同時又“積極”地等待條件發生改變.而且只有在一個notify()或notifyAll()發生變化的時候，線程纔會被喚醒，並檢查條件是否有變."
我們來解釋一下這句話.
"wait()允許我們將線程置入“睡眠”狀態",也就是說,wait也是讓當前線程阻塞的,這一點和sleep或者suspend是相同的.那和sleep,suspend有什麼區別呢?
區別在於"(wait)同時又“積極”地等待條件發生改變",這一點很關鍵,sleep和suspend無法做到.因爲我們有時候需要通過同步（synchronized）的幫助來防止線程之間的衝突，而一旦使用同步,就要鎖定對象，也就是獲取對象鎖,其它要使用該對象鎖的線程都只能排隊等着, 等到同步方法或者同步塊裏的程序全部運行完纔有機會.在同步方法和同步塊中,無論sleep()還是suspend()都不可能自己被調用的時候解除鎖定,他們都霸佔着正在使用的對象鎖不放.
而wait卻可以,它可以讓同步方法或者同步塊暫時放棄對象鎖,而將它暫時讓給其它需要對象鎖的人(這裏應該是程序塊,或線程)用,這意味着可在執行wait()期間調用線程對象中的其他同步方法!在其它情況下(sleep啊,suspend啊),這是不可能的.
但是注意我前面說的,只是暫時放棄對象鎖,暫時給其它線程使用,我wait所在的線程還是要把這個對象鎖收回來的呀.wait什麼?就是wait別人用完了還給我啊！
好,那怎麼把對象鎖收回來呢?
第一種方法,限定借出去的時間.在wait()中設置參數,比如wait(1000),以毫秒爲單位,就表明我只借出去1秒中,一秒鐘之後,我自動收回.
第二種方法,讓借出去的人通知我,他用完了,要還給我了.這時,我馬上就收回來.哎,假如我設了1小時之後收回,別人只用了半小時就完了,那怎麼辦呢?靠!當然用完了就收回了,還管我設的是多長時間啊.
那麼別人怎麼通知我呢?相信大家都可以想到了,notify(),這就是最後一句話"而且只有在一個notify()或notifyAll()發生變化的時候，線程纔會被喚醒"的意思了.
因此,我們可將一個wait()和notify()置入任何同步方法或同步塊內部，無論在那個類裏是否準備進行涉及線程的處理。而且實際上,我們也只能在同步方法或者同步塊裏面調用wait()和notify().
這個時候我們來解釋上面的程序,簡直是易如反掌了.
synchronized(b){...}；的意思是定義一個同步塊,使用b作爲資源鎖。b.wait();的意思是臨時釋放鎖，並阻塞當前線程,好讓其他使用同一把鎖的線程有機會執行,在這裏要用同一把鎖的就是b線程本身.這個線程在執行到一定地方後用notify()通知wait的線程,鎖已經用完, 待notify()所在的同步塊運行完之後,wait所在的線程就可以繼續執行.
java多線程設計wait/notify機制
多線程之間需要協調工作。例如，瀏覽器的一個顯示圖片的線程displayThread想要執行顯示圖片的任務，必須等待下載線程 downloadThread將該圖片下載完畢。如果圖片還沒有下載完，displayThread可以暫停，當downloadThread完成了任務後，再通知displayThread“圖片準備完畢，可以顯示了”，這時，displayThread繼續執行。
以上邏輯簡單的說就是：如果條件不滿足，則等待。當條件滿足時，等待該條件的線程將被喚醒。在Java中，這個機制的實現依賴於wait/notify。等待機制與鎖機制是密切關聯的。例如：
synchronized(obj) {
while(!condition) {
obj.wait();
}
obj.doSomething();
}
當線程A獲得了obj鎖後，發現條件condition不滿足，無法繼續下一處理，於是線程A就wait()。
在另一線程B中，如果B更改了某些條件，使得線程A的condition條件滿足了，就可以喚醒線程A：
synchronized(obj) {
condition = true;
obj.notify();
}
需要注意的概念是：
# 調用obj的wait(), notify()方法前，必須獲得obj鎖，也就是必須寫在synchronized(obj) {...} 代碼段內。
# 調用obj.wait()後，線程A就釋放了obj的鎖，否則線程B無法獲得obj鎖，也就無法在synchronized(obj) {...} 代碼段內喚醒A。
# 當obj.wait()方法返回後，線程A需要再次獲得obj鎖，才能繼續執行。
# 如果A1,A2,A3都在obj.wait()，則B調用obj.notify()只能喚醒A1,A2,A3中的一個（具體哪一個由JVM決定）。
# obj.notifyAll()則能全部喚醒A1,A2,A3，但是要繼續執行obj.wait()的下一條語句，必須獲得obj鎖，因此，A1,A2,A3只有一個有機會獲得鎖繼續執行，例如A1，其餘的需要等待A1釋放obj鎖之後才能繼續執行。
# 當B調用obj.notify/notifyAll的時候，B正持有obj鎖，因此，A1,A2,A3雖被喚醒，但是仍無法獲得obj鎖。直到B退出synchronized塊，釋放obj鎖後，A1,A2,A3中的一個纔有機會獲得鎖繼續執行。
synchronized的4種用法
1.方法聲明時使用,放在範圍操作符(public等)之後,返回類型聲明(void等)之前.即一次只能有一個線程進入該方法,其他線程要想在此時調用該方法,只能排隊等候,當前線程(就是在synchronized方法內部的線程)執行完該方法後,別的線程才能進入.
例如:
public synchronized void synMethod() {
//方法體
}
2.對某一代碼塊使用,synchronized後跟括號,括號裏是變量,這樣,一次只有一個線程進入該代碼塊.例如:
public int synMethod(int a1){
synchronized(a1) {
//一次只能有一個線程進入
}
}
3.synchronized後面括號裏是一對象,此時,線程獲得的是對象鎖.例如:
public class MyThread implements Runnable {
public static void main(String args[]) {
MyThread mt = new MyThread();
Thread t1 = new Thread(mt, "t1");
Thread t2 = new Thread(mt, "t2");
Thread t3 = new Thread(mt, "t3");
Thread t4 = new Thread(mt, "t4");
Thread t5 = new Thread(mt, "t5");
Thread t6 = new Thread(mt, "t6");
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
t6.start();
}
public void run() {
synchronized (this) {
System.out.println(Thread.currentThread().getName());
}
}
}
對於3,如果線程進入,則得到對象鎖,那麼別的線程在該類所有對象上的任何操作都不能進行.在對象級使用鎖通常是一種比較粗糙的方法。爲什麼要將整個對象都上鎖，而不允許其他線程短暫地使用對象中其他同步方法來訪問共享資源？如果一個對象擁有多個資源，就不需要只爲了讓一個線程使用其中一部分資源，就將所有線程都鎖在外面。由於每個對象都有鎖，可以如下所示使用虛擬對象來上鎖：
class FineGrainLock {
MyMemberClass x, y;
Object xlock = new Object(), ylock = new Object();
public void foo() {
synchronized(xlock) {
//access x here
}
//do something here - but don't use shared resources
synchronized(ylock) {
//access y here
}
}
public void bar() {
synchronized(this) {
//access both x and y here
}
//do something here - but don't use shared resources
}
}
4.synchronized後面括號裏是類.例如:
class ArrayWithLockOrder{
private static long num_locks = 0;
private long lock_order;
private int[] arr;
public ArrayWithLockOrder(int[] a)
{
arr = a;
synchronized(ArrayWithLockOrder.class) {//-----------------------------------------這裏
num_locks++; // 鎖數加 1。
lock_order = num_locks; // 爲此對象實例設置唯一的 lock_order。
}
}
public long lockOrder()
{
return lock_order;
}
public int[] array()
{
return arr;
}
}
class SomeClass implements Runnable
{
public int sumArrays(ArrayWithLockOrder a1,
ArrayWithLockOrder a2)
{
int value = 0;
ArrayWithLockOrder first = a1; // 保留數組引用的一個
ArrayWithLockOrder last = a2; // 本地副本。
int size = a1.array().length;
if (size == a2.array().length)
{
if (a1.lockOrder() > a2.lockOrder()) // 確定並設置對象的鎖定
{ // 順序。
first = a2;
last = a1;
}
synchronized(first) { // 按正確的順序鎖定對象。
synchronized(last) {
int[] arr1 = a1.array();
int[] arr2 = a2.array();
for (int i=0; i value += arr1[i] + arr2[i];
}
}
}
return value;
}
public void run() {
//...
}
}
對於4,如果線程進入,則線程在該類中所有操作不能進行,包括靜態變量和靜態方法,實際上,對於含有靜態方法和靜態變量的代碼塊的同步,我們通常用4來加鎖.
以上4種之間的關係：
鎖是和對象相關聯的，每個對象有一把鎖，爲了執行synchronized語句，線程必須能夠獲得synchronized語句中表達式指定的對象的鎖，一個對象只有一把鎖，被一個線程獲得之後它就不再擁有這把鎖，線程在執行完synchronized語句後，將獲得鎖交還給對象。
在方法前面加上synchronized修飾符即可以將一個方法聲明爲同步化方法。同步化方法在執行之前獲得一個鎖。如果這是一個類方法，那麼獲得的鎖是和聲明方法的類相關的Class類對象的鎖。如果這是一個實例方法，那麼此鎖是this對象的鎖。
下面談一談一些常用的方法:
wait(),wait(long),notify(),notifyAll()等方法是當前類的實例方法,
wait()是使持有對象鎖的線程釋放鎖;
wait(long)是使持有對象鎖的線程釋放鎖時間爲long(毫秒)後,再次獲得鎖,wait()和wait(0)等價;
notify()是喚醒一個正在等待該對象鎖的線程,如果等待的線程不止一個,那麼被喚醒的線程由jvm確定;
notifyAll是喚醒所有正在等待該對象鎖的線程.
在這裏我也重申一下,我們應該優先使用notifyAll()方法,因爲喚醒所有線程比喚醒一個線程更容易讓jvm找到最適合被喚醒的線程.
對於上述方法,只有在當前線程中才能使用,否則報運行時錯誤java.lang.IllegalMonitorStateException: current thread not owner.
下面,我談一下synchronized和wait()、notify()等的關係:
1.有synchronized的地方不一定有wait,notify
2.有wait,notify的地方必有synchronized.這是因爲wait和notify不是屬於線程類，而是每一個對象都具有的方法，而且，這兩個方法都和對象鎖有關，有鎖的地方，必有synchronized。
另外，請注意一點：如果要把notify和wait方法放在一起用的話，必須先調用notify後調用wait，因爲如果調用完wait，該線程就已經不是current thread了。如下例：
/**
* Title: Jdeveloper's Java Projdect
* Description: n/a
* Copyright: Copyright (c) 2001
* Company: soho http://www.ChinaJavaWorld.com
* @author [email protected]
* @version 1.0
*/
import java.lang.Runnable;
import java.lang.Thread;
public class DemoThread
implements Runnable {
public DemoThread() {
TestThread testthread1 = new TestThread(this, "1");
TestThread testthread2 = new TestThread(this, "2");
testthread2.start();
testthread1.start();
}
public static void main(String[] args) {
DemoThread demoThread1 = new DemoThread();
}
public void run() {
TestThread t = (TestThread) Thread.currentThread();
try {
if (!t.getName().equalsIgnoreCase("1")) {
synchronized (this) {
wait();
}
}
while (true) {
System.out.println("@time in thread" + t.getName() + "=" +
t.increaseTime());
if (t.getTime() % 10 == 0) {
synchronized (this) {
System.out.println("****************************************");
notify();
if (t.getTime() == 100)
break;
wait();
}
}
}
}
catch (Exception e) {
e.printStackTrace();
}
}
}
class TestThread
extends Thread {
private int time = 0;
public TestThread(Runnable r, String name) {
super(r, name);
}
public int getTime() {
return time;
}
public int increaseTime() {
return++time;
}
}
下面我們用生產者/消費者這個例子來說明他們之間的關係:
public class test {
public static void main(String args[]) {
Semaphore s = new Semaphore(1);
Thread t1 = new Thread(s, "producer1");
Thread t2 = new Thread(s, "producer2");
Thread t3 = new Thread(s, "producer3");
Thread t4 = new Thread(s, "consumer1");
Thread t5 = new Thread(s, "consumer2");
Thread t6 = new Thread(s, "consumer3");
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
t6.start();
}
}
class Semaphore
implements Runnable {
private int count;
public Semaphore(int n) {
this.count = n;
}
public synchronized void acquire() {
while (count == 0) {
try {
wait();
}
catch (InterruptedException e) {
//keep trying
}
}
count--;
}
public synchronized void release() {
while (count == 10) {
try {
wait();
}
catch (InterruptedException e) {
//keep trying
}
}
count++;
notifyAll(); //alert a thread that's blocking on this semaphore
}
public void run() {
while (true) {
if (Thread.currentThread().getName().substring(0,8).equalsIgnoreCase("consumer")) {
acquire();
}
else if (Thread.currentThread().getName().substring(0,8).equalsIgnoreCase("producer")) {
release();
}
System.out.println(Thread.currentThread().getName() + " " + count);
}
}
}
生產者生產,消費者消費,一般沒有衝突,但當庫存爲0時,消費者要消費是不行的,但當庫存爲上限(這裏是10)時,生產者也不能生產.請好好研讀上面的程序,你一定會比以前進步很多.
上面的代碼說明了synchronized和wait,notify沒有絕對的關係,在synchronized聲明的方法、代碼塊中,你完全可以不用 wait,notify等方法,但是,如果當線程對某一資源存在某種爭用的情況下,你必須適時得將線程放入等待或者喚醒.