|
例子：有一家漢堡店舉辦吃漢堡比賽，決賽時有3個顧客來吃，3個廚師來做，一個服務員負責協調漢堡的數量。為了避免浪費，制作好的漢堡被放進一個能裝有10個漢堡的長條狀容器中，按照先進先出的原則取漢堡。如果容器被裝滿，則廚師停止做漢堡，如果顧客發現容器內的漢堡吃完了，就可以拍響容器上的鬧鈴，提醒廚師再做幾個漢堡出來。此時服務員過來安撫顧客，讓他等待。而一旦廚師的漢堡做出來，就會讓服務員通知顧客，漢堡做好了，讓顧客繼續過來取漢堡。
這里，顧客其實就是我們所說的消費者，而廚師就是生產者。容器是決定廚師行為的監視器，而服務員則負責監視顧客的行為。
在JVM中，此種監視器被稱為等待并喚醒監視器。
|
|
在這種監視器中，一個已經持有該監視器的線程，可以通過調用監視對象的wait方法，暫停自身的執行，并釋放監視器，自己進入一個等待區，直到監視器內的其他線程調用了監視對象的notify方法。 當一個線程調用喚醒命令以后，它會持續持有監視器，直到它主動釋放監視器。而這之后，等待線程會蘇醒，其中的一個會重新獲得監視器，判斷條件狀態，以便決定是否繼續進入等待狀態或者執行監視區域，或者退出。
請看下面的代碼：
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. }
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
這段代碼啟動了三個簡單的wait線程，當他們處于等待狀態以后，試圖由一個notify線程來喚醒。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
運行這段程序，你會發現，滿屏的java.lang.IllegalMonitorStateException，根本不是你想要的結果。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
請注意以下幾個事實：
1. 任何一個時刻，對象的控制權（monitor）只能被一個線程擁有。
2. 無論是執行對象的wait、notify還是notifyAll方法，必須保證當前運行的線程取得了該對象的控制權（monitor）。
3. 如果在沒有控制權的線程里執行對象的以上三種方法，就會報java.lang.IllegalMonitorStateException異常。
4. JVM基于多線程，默認情況下不能保證運行時線程的時序性。
也就是說，當線程在調用某個對象的wait或者notify方法的時候，要先取得該對象的控制權，換句話說，就是進入這個對象的監視器。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
通過前面對同步的討論，我們知道，要讓一個線程進入某個對象的監視器，通常有三種方法：
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
1： 執行對象的某個同步實例方法
2： 執行對象對應的同步靜態方法
3： 執行對該對象加同步鎖的同步塊
顯然，在上面的例程中，我們用第三種方法比較合適。
于是我們將上面的wait和notify方法調用包在同步塊中。
1. synchronized (flag) {
2. flag = "false";
3. flag.notify();
4. }
轉載注明出處：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. }
但是，運行這個程序，我們發現事與愿違。那個非法監視器異常又出現了。。。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
我們注意到，針對flag的同步塊中，我們實際上已經更改了flag對對象的引用： flag="false";
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
顯然，這樣一來，同步塊也無能為力了，因為我們根本不是針對唯一的一個對象在進行同步。
我們不妨將flag封裝到JavaBean或者數組中去，這樣用JavaBean對象或者數組對象進行同步，就可以達到既能修改里面參數又不耽誤同步的目的。
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. }
運行這個程序，看不到異常了。但是仔細觀察結果，貌似只有一個線程被喚醒。利用jconsole等工具查看線程狀態，發現的確還是有兩個線程被阻塞的。這是為啥呢？
程序中使用了flag.notify()方法。只能是隨機的喚醒一個線程。我們可以改用flag.notifyAll()方法。這樣，所有被阻塞的線程都會被喚醒了。
最終代碼請讀者自己修改，這里不再贅述。
好了，親愛的讀者們，讓我們回到開篇提到的漢堡店大賽問題當中去，來看一看廚師、服務生和顧客是怎么協作進行這個比賽的。
首先我們構造故事中的三個次要對象：漢堡包、存放漢堡包的容器、服務生
public class Waiter {//服務生，這是個配角，不需要屬性。
}
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();
}
//判斷容器內漢堡的個數
public int size() {
return hambergs.size();
}
//返回容器的最大容量
public int getMaxSize() {
return this.maxSize;
}
}
接下來我們構造廚師對象：
class Cooker implements Runnable {
//廚師要面對容器
HambergFifo pool;
//還要面對服務生
Waiter waiter;
public Cooker(Waiter waiter, HambergFifo hambergStack) {
this.pool = hambergStack;
this.waiter = waiter;
}
//制造漢堡
public void makeHamberg() {
//制造的個數
int madeCount = 0;
//因為容器滿，被迫等待的次數
int fullFiredCount = 0;
try {
while (true) {
//制作漢堡前的準備工作
Thread.sleep(1000);
if (pool.size() < pool.getMaxSize()) {
synchronized (waiter) {
//容器未滿，制作漢堡，并放入容器。
pool.push(new Hamberg(++madeCount,Thread.currentThread().getName()));
//說出容器內漢堡數量
System.out.println(Thread.currentThread().getName() + ": There are "
+ pool.size() + " Hambergs in all");
//讓服務生通知顧客，有漢堡可以吃了
waiter.notifyAll();
System.out.println("### Cooker: waiter.notifyAll() :"+
" Hi! Customers, we got some new Hambergs!");
}
} else {
synchronized (pool) {
if (fullFiredCount++ < 10) {
//發現容器滿了，停止做漢堡的嘗試。
System.out.println(Thread.currentThread().getName() +
": Hamberg Pool is Full, Stop making hamberg");
System.out.println("### Cooker: pool.wait()");
//漢堡容器的狀況使廚師等待
pool.wait();
} else {
return;
}
}
}
//做完漢堡要進行收尾工作，為下一次的制作做準備。
Thread.sleep(1000);
}
} catch (Exception e) {
madeCount--;
e.printStackTrace();
}
}
public void run() {
makeHamberg();
}
}
接下來，我們構造顧客對象：
class Customer implements Runnable {
//顧客要面對服務生
Waiter waiter;
//也要面對漢堡包容器
HambergFifo pool;
//想要記下自己吃了多少漢堡
int ateCount = 0;
//吃每個漢堡的時間不盡相同
long sleeptime;
//用于產生隨機數
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());
//若取不到漢堡，要和服務生打交道
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");
//服務生安撫顧客，讓他等待。
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 {
//在容器內取漢堡
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]");
}
}
}
}
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
最后，我們構造漢堡店，讓這個故事發生：
轉載注明出處：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();
}
}
運行這個程序吧，然后你會看到我們漢堡店的比賽進行的很好，只是不
知道那些顧客是不是會被撐到。。。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
讀到這里，有的讀者可能會想到前面介紹的重入鎖ReentrantLock。
有的讀者會問：如果我用ReentrantLock來代替上面這些例程當中的 synchronized塊，是不是也可以呢？感興趣的讀者不妨一試。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
但是在這里，我想提前給出結論，就是，
如果用ReentrantLock的lock()和unlock()方法代替上面的synchronized塊，那么上面這些程序還是要拋出 java.lang.IllegalMonitorStateException異常的，不僅如此，你甚至還會看到線程死鎖。原因就是當某個線程調用第三方對象的wait或者notify方法的時候，并沒有進入第三方對象的監視器，于是拋出了異常信息。但此時，程序流程如果沒有用finally來處理 unlock方法，那么你的線程已經被lock方法上鎖，并且無法解鎖。程序在java.util.concurrent框架的語義級別死鎖了，你用 JConsole這種工具來檢測JVM死鎖，還檢測不出來。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
正確的做法就是，只使用ReentrantLock，而不使用wait或者notify方法。因為ReentrantLock已經對這種互斥和協作進行了概括。所以，根據你程序的需要，請單獨采用重入鎖或者synchronized一種同步機制，最好不要混用。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
好了，我們現在明白：轉載注明出處：http://x- spirit.javaeye.com/、http: //www.blogjava.net/zhangwei217245/
1. 線程的等待或者喚醒，并不是讓線程調用自己的wait或者notify方法，而是通過調用線程共享對象的wait或者notify方法來實現。
2. 線程要調用某個對象的wait或者notify方法，必須先取得該對象的監視器。
3. 線程的協作必須以線程的互斥為前提，這種協作實際上是一種互斥下的協作。
posted on 2011-07-25 20:10
雪黛依夢 閱讀(2691)
評論(0) 編輯 收藏 引用 所屬分類:
JAVA--J2SE