|
例子：有一家漢堡店舉辦吃漢堡比賽，決賽時有3個顧客來吃，3個廚師來做，一個服務(wù)員負(fù)責(zé)協(xié)調(diào)漢堡的數(shù)量。為了避免浪費(fèi)，制作好的漢堡被放進(jìn)一個能裝有10個漢堡的長條狀容器中，按照先進(jìn)先出的原則取漢堡。如果容器被裝滿，則廚師停止做漢堡，如果顧客發(fā)現(xiàn)容器內(nèi)的漢堡吃完了，就可以拍響容器上的鬧鈴，提醒廚師再做幾個漢堡出來。此時服務(wù)員過來安撫顧客，讓他等待。而一旦廚師的漢堡做出來，就會讓服務(wù)員通知顧客，漢堡做好了，讓顧客繼續(xù)過來取漢堡。
這里，顧客其實(shí)就是我們所說的消費(fèi)者，而廚師就是生產(chǎn)者。容器是決定廚師行為的監(jiān)視器，而服務(wù)員則負(fù)責(zé)監(jiān)視顧客的行為。
在JVM中，此種監(jiān)視器被稱為等待并喚醒監(jiān)視器。
|
|
在這種監(jiān)視器中，一個已經(jīng)持有該監(jiān)視器的線程，可以通過調(diào)用監(jiān)視對象的wait方法，暫停自身的執(zhí)行，并釋放監(jiān)視器，自己進(jìn)入一個等待區(qū)，直到監(jiān)視器內(nèi)的其他線程調(diào)用了監(jiān)視對象的notify方法。 當(dāng)一個線程調(diào)用喚醒命令以后，它會持續(xù)持有監(jiān)視器，直到它主動釋放監(jiān)視器。而這之后，等待線程會蘇醒，其中的一個會重新獲得監(jiān)視器，判斷條件狀態(tài)，以便決定是否繼續(xù)進(jìn)入等待狀態(tài)或者執(zhí)行監(jiān)視區(qū)域，或者退出。
請看下面的代碼：
1. public class NotifyTest {
2. private String flag = "true";
3.
4. class NotifyThread extends Thread{
5. public NotifyThread(String name) {
6. super(name);
7. }
8. public void run() {
9. try {
10. sleep(3000);//推遲3秒鐘通知
11. } catch (InterruptedException e) {
12. e.printStackTrace();
13. }
14.
15. flag = "false";
16. flag.notify();
17. }
18. };
19.
20. class WaitThread extends Thread {
21. public WaitThread(String name) {
22. super(name);
23. }
24.
25. public void run() {
26.
27. while (flag!="false") {
28. System.out.println(getName() + " begin waiting!");
29. long waitTime = System.currentTimeMillis();
30. try {
31. flag.wait();
32. } catch (InterruptedException e) {
33. e.printStackTrace();
34. }
35. waitTime = System.currentTimeMillis() - waitTime;
36. System.out.println("wait time :"+waitTime);
37. }
38. System.out.println(getName() + " end waiting!");
39.
40. }
41. }
42.
43. public static void main(String[] args) throws InterruptedException {
44. System.out.println("Main Thread Run!");
45. NotifyTest test = new NotifyTest();
46. NotifyThread notifyThread =test.new NotifyThread("notify01");
47. WaitThread waitThread01 = test.new WaitThread("waiter01");
48. WaitThread waitThread02 = test.new WaitThread("waiter02");
49. WaitThread waitThread03 = test.new WaitThread("waiter03");
50. notifyThread.start();
51. waitThread01.start();
52. waitThread02.start();
53. waitThread03.start();
54. }
55.
56. }
轉(zhuǎn)載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
這段代碼啟動了三個簡單的wait線程，當(dāng)他們處于等待狀態(tài)以后，試圖由一個notify線程來喚醒。
轉(zhuǎn)載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
運(yùn)行這段程序，你會發(fā)現(xiàn)，滿屏的java.lang.IllegalMonitorStateException，根本不是你想要的結(jié)果。
轉(zhuǎn)載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
請注意以下幾個事實(shí)：
1. 任何一個時刻，對象的控制權(quán)（monitor）只能被一個線程擁有。
2. 無論是執(zhí)行對象的wait、notify還是notifyAll方法，必須保證當(dāng)前運(yùn)行的線程取得了該對象的控制權(quán)（monitor）。
3. 如果在沒有控制權(quán)的線程里執(zhí)行對象的以上三種方法，就會報java.lang.IllegalMonitorStateException異常。
4. JVM基于多線程，默認(rèn)情況下不能保證運(yùn)行時線程的時序性。
也就是說，當(dāng)線程在調(diào)用某個對象的wait或者notify方法的時候，要先取得該對象的控制權(quán)，換句話說，就是進(jìn)入這個對象的監(jiān)視器。
轉(zhuǎn)載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
通過前面對同步的討論，我們知道，要讓一個線程進(jìn)入某個對象的監(jiān)視器，通常有三種方法：
轉(zhuǎn)載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
1： 執(zhí)行對象的某個同步實(shí)例方法
2： 執(zhí)行對象對應(yīng)的同步靜態(tài)方法
3： 執(zhí)行對該對象加同步鎖的同步塊
顯然，在上面的例程中，我們用第三種方法比較合適。
于是我們將上面的wait和notify方法調(diào)用包在同步塊中。
1. synchronized (flag) {
2. flag = "false";
3. flag.notify();
4. }
轉(zhuǎn)載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
1. synchronized (flag) {
2. while (flag!="false") {
3. System.out.println(getName() + " begin waiting!");
4. long waitTime = System.currentTimeMillis();
5. try {
6. flag.wait();
7. } catch (InterruptedException e) {
8. e.printStackTrace();
9. }
10. waitTime = System.currentTimeMillis() - waitTime;
11. System.out.println("wait time :"+waitTime);
12. }
13. System.out.println(getName() + " end waiting!");
14. }
但是，運(yùn)行這個程序，我們發(fā)現(xiàn)事與愿違。那個非法監(jiān)視器異常又出現(xiàn)了。。。
轉(zhuǎn)載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
我們注意到，針對flag的同步塊中，我們實(shí)際上已經(jīng)更改了flag對對象的引用： flag="false";
轉(zhuǎn)載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
顯然，這樣一來，同步塊也無能為力了，因?yàn)槲覀兏静皇轻槍ξㄒ坏囊粋€對象在進(jìn)行同步。
我們不妨將flag封裝到JavaBean或者數(shù)組中去，這樣用JavaBean對象或者數(shù)組對象進(jìn)行同步，就可以達(dá)到既能修改里面參數(shù)又不耽誤同步的目的。
1. private String flag[] = {"true"};
1. synchronized (flag) {
2. flag[0] = "false";
3. flag.notify();
4. }
1. synchronized (flag) {
2. flag[0] = "false";
3. flag.notify();
4. }synchronized (flag) {
5. while (flag[0]!="false") {
6. System.out.println(getName() + " begin waiting!");
7. long waitTime = System.currentTimeMillis();
8. try {
9. flag.wait();
10.
11. } catch (InterruptedException e) {
12. e.printStackTrace();
13. }
運(yùn)行這個程序，看不到異常了。但是仔細(xì)觀察結(jié)果，貌似只有一個線程被喚醒。利用jconsole等工具查看線程狀態(tài)，發(fā)現(xiàn)的確還是有兩個線程被阻塞的。這是為啥呢？
程序中使用了flag.notify()方法。只能是隨機(jī)的喚醒一個線程。我們可以改用flag.notifyAll()方法。這樣，所有被阻塞的線程都會被喚醒了。
最終代碼請讀者自己修改，這里不再贅述。
好了，親愛的讀者們，讓我們回到開篇提到的漢堡店大賽問題當(dāng)中去，來看一看廚師、服務(wù)生和顧客是怎么協(xié)作進(jìn)行這個比賽的。
首先我們構(gòu)造故事中的三個次要對象：漢堡包、存放漢堡包的容器、服務(wù)生
public class Waiter {//服務(wù)生，這是個配角，不需要屬性。
}
class Hamberg {
//漢堡包
private int id;//漢堡編號
private String cookerid;//廚師編號
public Hamberg(int id, String cookerid){
this.id = id;
this.cookerid = cookerid;
System.out.println(this.toString()+"was made!");
}
@Override
public String toString() {
return "#"+id+" by "+cookerid;
}
}
class HambergFifo {
//漢堡包容器
List<Hamberg> hambergs = new ArrayList<Hamberg>();//借助ArrayList來存放漢堡包
int maxSize = 10;//指定容器容量
//放入漢堡
public <T extends Hamberg> void push(T t) {
hambergs.add(t);
}
//取出漢堡
public Hamberg pop() {
Hamberg h = hambergs.get(0);
hambergs.remove(0);
return h;
}
//判斷容器是否為空
public boolean isEmpty() {
return hambergs.isEmpty();
}
//判斷容器內(nèi)漢堡的個數(shù)
public int size() {
return hambergs.size();
}
//返回容器的最大容量
public int getMaxSize() {
return this.maxSize;
}
}
接下來我們構(gòu)造廚師對象：
class Cooker implements Runnable {
//廚師要面對容器
HambergFifo pool;
//還要面對服務(wù)生
Waiter waiter;
public Cooker(Waiter waiter, HambergFifo hambergStack) {
this.pool = hambergStack;
this.waiter = waiter;
}
//制造漢堡
public void makeHamberg() {
//制造的個數(shù)
int madeCount = 0;
//因?yàn)槿萜鳚M，被迫等待的次數(shù)
int fullFiredCount = 0;
try {
while (true) {
//制作漢堡前的準(zhǔn)備工作
Thread.sleep(1000);
if (pool.size() < pool.getMaxSize()) {
synchronized (waiter) {
//容器未滿，制作漢堡，并放入容器。
pool.push(new Hamberg(++madeCount,Thread.currentThread().getName()));
//說出容器內(nèi)漢堡數(shù)量
System.out.println(Thread.currentThread().getName() + ": There are "
+ pool.size() + " Hambergs in all");
//讓服務(wù)生通知顧客，有漢堡可以吃了
waiter.notifyAll();
System.out.println("### Cooker: waiter.notifyAll() :"+
" Hi! Customers, we got some new Hambergs!");
}
} else {
synchronized (pool) {
if (fullFiredCount++ < 10) {
//發(fā)現(xiàn)容器滿了，停止做漢堡的嘗試。
System.out.println(Thread.currentThread().getName() +
": Hamberg Pool is Full, Stop making hamberg");
System.out.println("### Cooker: pool.wait()");
//漢堡容器的狀況使廚師等待
pool.wait();
} else {
return;
}
}
}
//做完漢堡要進(jìn)行收尾工作，為下一次的制作做準(zhǔn)備。
Thread.sleep(1000);
}
} catch (Exception e) {
madeCount--;
e.printStackTrace();
}
}
public void run() {
makeHamberg();
}
}
接下來，我們構(gòu)造顧客對象：
class Customer implements Runnable {
//顧客要面對服務(wù)生
Waiter waiter;
//也要面對漢堡包容器
HambergFifo pool;
//想要記下自己吃了多少漢堡
int ateCount = 0;
//吃每個漢堡的時間不盡相同
long sleeptime;
//用于產(chǎn)生隨機(jī)數(shù)
Random r = new Random();
public Customer(Waiter waiter, HambergFifo pool) {
this.waiter = waiter;
this.pool = pool;
}
public void run() {
while (true) {
try {
//取漢堡
getHamberg();
//吃漢堡
eatHamberg();
} catch (Exception e) {
synchronized (waiter) {
System.out.println(e.getMessage());
//若取不到漢堡，要和服務(wù)生打交道
try {
System.out.println("### Customer: waiter.wait():"+
" Sorry, Sir, there is no hambergs left, please wait!");
System.out.println(Thread.currentThread().getName()
+ ": OK, Waiting for new hambergs");
//服務(wù)生安撫顧客，讓他等待。
waiter.wait();
continue;
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}
}
private void eatHamberg() {
try {
//吃每個漢堡的時間不等
sleeptime = Math.abs(r.nextInt(3000)) * 5;
System.out.println(Thread.currentThread().getName()
+ ": I'm eating the hamberg for " + sleeptime + " milliseconds");
Thread.sleep(sleeptime);
} catch (Exception e) {
e.printStackTrace();
}
}
private void getHamberg() throws Exception {
Hamberg hamberg = null;
synchronized (pool) {
try {
//在容器內(nèi)取漢堡
hamberg = pool.pop();
ateCount++;
System.out.println(Thread.currentThread().getName()
+ ": I Got " + ateCount + " Hamberg " + hamberg);
System.out.println(Thread.currentThread().getName()
+ ": There are still " + pool.size() + " hambergs left");
} catch (Exception e) {
pool.notifyAll();
System.out.println("### Customer: pool.notifyAll()");
throw new Exception(Thread.currentThread().getName() +
": OH MY GOD!!!! No hambergs left, Waiter![Ring the bell besides the hamberg pool]");
}
}
}
}
轉(zhuǎn)載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
最后，我們構(gòu)造漢堡店，讓這個故事發(fā)生：
轉(zhuǎn)載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
public class HambergShop {
Waiter waiter = new Waiter();
HambergFifo hambergPool = new HambergFifo();
Customer c1 = new Customer(waiter, hambergPool);
Customer c2 = new Customer(waiter, hambergPool);
Customer c3 = new Customer(waiter, hambergPool);
Cooker cooker = new Cooker(waiter, hambergPool);
public static void main(String[] args) {
HambergShop hambergShop = new HambergShop();
Thread t1 = new Thread(hambergShop.c1, "Customer 1");
Thread t2 = new Thread(hambergShop.c2, "Customer 2");
Thread t3 = new Thread(hambergShop.c3, "Customer 3");
Thread t4 = new Thread(hambergShop.cooker, "Cooker 1");
Thread t5 = new Thread(hambergShop.cooker, "Cooker 2");
Thread t6 = new Thread(hambergShop.cooker, "Cooker 3");
t4.start();
t5.start();
t6.start();
try {
Thread.sleep(10000);
} catch (Exception e) {
}
t1.start();
t2.start();
t3.start();
}
}
運(yùn)行這個程序吧，然后你會看到我們漢堡店的比賽進(jìn)行的很好，只是不
知道那些顧客是不是會被撐到。。。
轉(zhuǎn)載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
讀到這里，有的讀者可能會想到前面介紹的重入鎖ReentrantLock。
有的讀者會問：如果我用ReentrantLock來代替上面這些例程當(dāng)中的 synchronized塊，是不是也可以呢？感興趣的讀者不妨一試。
轉(zhuǎn)載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
但是在這里，我想提前給出結(jié)論，就是，
如果用ReentrantLock的lock()和unlock()方法代替上面的synchronized塊，那么上面這些程序還是要拋出 java.lang.IllegalMonitorStateException異常的，不僅如此，你甚至還會看到線程死鎖。原因就是當(dāng)某個線程調(diào)用第三方對象的wait或者notify方法的時候，并沒有進(jìn)入第三方對象的監(jiān)視器，于是拋出了異常信息。但此時，程序流程如果沒有用finally來處理 unlock方法，那么你的線程已經(jīng)被lock方法上鎖，并且無法解鎖。程序在java.util.concurrent框架的語義級別死鎖了，你用 JConsole這種工具來檢測JVM死鎖，還檢測不出來。
轉(zhuǎn)載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
正確的做法就是，只使用ReentrantLock，而不使用wait或者notify方法。因?yàn)镽eentrantLock已經(jīng)對這種互斥和協(xié)作進(jìn)行了概括。所以，根據(jù)你程序的需要，請單獨(dú)采用重入鎖或者synchronized一種同步機(jī)制，最好不要混用。
轉(zhuǎn)載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
好了，我們現(xiàn)在明白：轉(zhuǎn)載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
1. 線程的等待或者喚醒，并不是讓線程調(diào)用自己的wait或者notify方法，而是通過調(diào)用線程共享對象的wait或者notify方法來實(shí)現(xiàn)。
2. 線程要調(diào)用某個對象的wait或者notify方法，必須先取得該對象的監(jiān)視器。
3. 線程的協(xié)作必須以線程的互斥為前提，這種協(xié)作實(shí)際上是一種互斥下的協(xié)作。
posted on 2011-07-25 20:10
雪黛依夢 閱讀(2697)
評論(0) 編輯 收藏 引用 所屬分類:
JAVA--J2SE