synchorize方法或獲取對象內部的鎖，之後可以對對象做wait，notify，notifyAll操作。

condition是與lock關聯的，對condition做single，await，也要先要lock住lock對象

最簡實例說明wait、notify、notifyAll的使用方法

• java 基礎

/**

* 轉載請註明作者longdick http://longdick.iteye.com

*

*/

wait()、notify()、notifyAll()是三個定義在Object類裏的方法，可以用來控制線程的狀態。

這三個方法最終調用的都是jvm級的native方法。隨著jvm運行平臺的不同可能有些許差異。

• 如果對象調用了wait方法就會使持有該對象的線程把該對象的控制權交出去，然後處於等待狀態。
• 如果對象調用了notify方法就會通知某個正在等待這個對象的控制權的線程可以繼續運行。
• 如果對象調用了notifyAll方法就會通知所有等待這個對象控制權的線程繼續運行。

其中wait方法有三個over load方法：

wait()

wait(long)

wait(long,int)

wait方法通過參數可以指定等待的時長。如果沒有指定參數，默認一直等待直到被通知。

以下是一個演示代碼，以最簡潔的方式說明復雜的問題：

簡要說明下：

NotifyThread是用來模擬3秒鐘後通知其他等待狀態的線程的線程類；

WaitThread是用來模擬等待的線程類；

等待的中間對象是flag，一個String對象；

main方法中同時啟動一個Notify線程和三個wait線程；

1. public class NotifyTest {
2. private String flag = "true";
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. }
15. flag = "false";
16. flag.notify();
17. }
18. };
20. class WaitThread extends Thread {
21. public WaitThread(String name) {
22. super(name);
23. }
25. public void run() {
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!");
40. }
41. }
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. }
56. }

OK，如果你拿這段程序去運行下的話， 會發現根本運行不了，what happened？滿屏的java.lang.IllegalMonitorStateException。

沒錯，這段程序有很多問題，我們一個個來看。

首先，這兒要非常註意的幾個事實是

1. 任何一個時刻，對象的控制權（monitor）只能被一個線程擁有。
2. 無論是執行對象的wait、notify還是notifyAll方法，必須保證當前運行的線程取得了該對象的控制權（monitor）
3. 如果在沒有控制權的線程裏執行對象的以上三種方法，就會報java.lang.IllegalMonitorStateException異常。
4. JVM基於多線程，默認情況下不能保證運行時線程的時序性

基於以上幾點事實，我們需要確保讓線程擁有對象的控制權。

也就是說在waitThread中執行wait方法時，要保證waitThread對flag有控制權；

在notifyThread中執行notify方法時，要保證notifyThread對flag有控制權。

線程取得控制權的方法有三：

1. 執行對象的某個同步實例方法。
2. 執行對象對應類的同步靜態方法。
3. 執行對該對象加同步鎖的同步塊。

1. synchronized (flag) {
2. flag = "false";
3. flag.notify();
4. }

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. }

我們向前進了一步。

問題解決了嗎？

好像運行還是報錯java.lang.IllegalMonitorStateException。what happened？

這時的異常是由於在針對flag對象同步塊中，更改了flag對象的狀態所導致的。如下：

flag="false";

flag.notify();

對在同步塊中對flag進行了賦值操作，使得flag引用的對象改變，這時候再調用notify方法時，因為沒有控制權所以拋出異常。

我們可以改進一下，將flag改成一個JavaBean，然後更改它的屬性不會影響到flag的引用。

我們這裏改成數組來試試，也可以達到同樣的效果：

1. private String flag[] = {"true"};

1. synchronized (flag) {
2. flag[0] = "false";
3. flag.notify();
4. }

1. synchronized (flag) {
2. while (flag[0]!="false") {
3. System.out.println(getName() + " begin waiting!");
4. long waitTime = System.currentTimeMillis();
5. try {
6. flag.wait();
8. } catch (InterruptedException e) {
9. e.printStackTrace();
10. }

這時候再運行，不再報異常，但是線程沒有結束是吧，沒錯，還有線程堵塞，處於wait狀態。

原因很簡單，我們有三個wait線程，只有一個notify線程，notify線程運行notify方法的時候，是隨機通知一個正在等待的線程，所以，現在應該還有兩個線程在waiting。

我們只需要將NotifyThread線程類中的flag.notify()方法改成notifyAll()就可以了。notifyAll方法會通知所有正在等待對象控制權的線程。

最終完成版如下：

1. public class NotifyTest {
2. private String flag[] = { "true" };
4. class NotifyThread extends Thread {
5. public NotifyThread(String name) {
6. super(name);
7. }
9. public void run() {
10. try {
11. sleep(3000);
12. } catch (InterruptedException e) {
13. e.printStackTrace();
14. }
15. synchronized (flag) {
16. flag[0] = "false";
17. flag.notifyAll();
18. }
19. }
20. };
22. class WaitThread extends Thread {
23. public WaitThread(String name) {
24. super(name);
25. }
27. public void run() {
28. synchronized (flag) {
29. while (flag[0] != "false") {
30. System.out.println(getName() + " begin waiting!");
31. long waitTime = System.currentTimeMillis();
32. try {
33. flag.wait();
35. } catch (InterruptedException e) {
36. e.printStackTrace();
37. }
38. waitTime = System.currentTimeMillis() - waitTime;
39. System.out.println("wait time :" + waitTime);
40. }
41. System.out.println(getName() + " end waiting!");
42. }
43. }
44. }
46. public static void main(String[] args) throws InterruptedException {
47. System.out.println("Main Thread Run!");
48. NotifyTest test = new NotifyTest();
49. NotifyThread notifyThread = test.new NotifyThread("notify01");
50. WaitThread waitThread01 = test.new WaitThread("waiter01");
51. WaitThread waitThread02 = test.new WaitThread("waiter02");
52. WaitThread waitThread03 = test.new WaitThread("waiter03");
53. notifyThread.start();
54. waitThread01.start();
55. waitThread02.start();
56. waitThread03.start();
57. }
59. }

最簡實例說明wait、notify、notifyAll的使用方法