轉載請註明出處：http://blog.csdn.net/ns_code/article/details/17228213

notify通知的遺漏很容易理解，即threadA還沒開始wait的時候，threadB已經notify了，這樣，threadB通知是沒有任何響應的，當threadB退出synchronized代碼塊後，threadA再開始wait，便會一直阻塞等待，直到被別的線程打斷。

遺漏通知的代碼

下面給出一段代碼演示通知是如何遺漏的，如下：

1. public class MissedNotify extends Object {
2. private Object proceedLock;
4. public MissedNotify() {
5. print("in MissedNotify()");
6. proceedLock = new Object();
7. }
9. public void waitToProceed() throws InterruptedException {
10. print("in waitToProceed() - entered");
12. synchronized ( proceedLock ) {
13. print("in waitToProceed() - about to wait()");
14. proceedLock.wait();
15. print("in waitToProceed() - back from wait()");
16. }
18. print("in waitToProceed() - leaving");
19. }
21. public void proceed() {
22. print("in proceed() - entered");
24. synchronized ( proceedLock ) {
25. print("in proceed() - about to notifyAll()");
26. proceedLock.notifyAll();
27. print("in proceed() - back from notifyAll()");
28. }
30. print("in proceed() - leaving");
31. }
33. private static void print(String msg) {
34. String name = Thread.currentThread().getName();
35. System.out.println(name + ": " + msg);
36. }
38. public static void main(String[] args) {
39. final MissedNotify mn = new MissedNotify();
41. Runnable runA = new Runnable() {
42. public void run() {
43. try {
44. //休眠1000ms，大於runB中的500ms，
45. //是為了後調用waitToProceed，從而先notifyAll，後wait，
46. //從而造成通知的遺漏
47. Thread.sleep(1000);
48. mn.waitToProceed();
49. } catch ( InterruptedException x ) {
50. x.printStackTrace();
51. }
52. }
53. };
55. Thread threadA = new Thread(runA, "threadA");
56. threadA.start();
58. Runnable runB = new Runnable() {
59. public void run() {
60. try {
61. //休眠500ms，小於runA中的1000ms，
62. //是為了先調用proceed，從而先notifyAll，後wait，
63. //從而造成通知的遺漏
64. Thread.sleep(500);
65. mn.proceed();
66. } catch ( InterruptedException x ) {
67. x.printStackTrace();
68. }
69. }
70. };
72. Thread threadB = new Thread(runB, "threadB");
73. threadB.start();
75. try {
76. Thread.sleep(10000);
77. } catch ( InterruptedException x ) {}
79. //試圖打斷wait阻塞
80. print("about to invoke interrupt() on threadA");
81. threadA.interrupt();
82. }
83. }

執行結果如下：

分析：由於threadB在執行mn.proceed（）之前只休眠了500ms，而threadA在執行mn.waitToProceed（）之前休眠了1000ms，因此，threadB會先蘇醒，繼而執行mn.proceed（），獲取到proceedLock的對象鎖，繼而執行其中的notifyAll（），當退出proceed（）方法中的synchronized代碼塊時，threadA才有機會獲取proceedLock的對象鎖，繼而執行其中的wait（）方法，但此時notifyAll（）方法已經執行完畢，threadA便漏掉了threadB的通知，便會阻塞下去。後面主線程休眠10秒後，嘗試中斷threadA線程，使其拋出InterruptedException。

修正後的代碼

為了修正MissedNotify，需要添加一個boolean指示變量，該變量只能在同步代碼塊內部訪問和修改。修改後的代碼如下：

1. public class MissedNotifyFix extends Object {
2. private Object proceedLock;
3. //該標誌位用來指示線程是否需要等待
4. private boolean okToProceed;
6. public MissedNotifyFix() {
7. print("in MissedNotify()");
8. proceedLock = new Object();
9. //先設置為false
10. okToProceed = false;
11. }
13. public void waitToProceed() throws InterruptedException {
14. print("in waitToProceed() - entered");
16. synchronized ( proceedLock ) {
17. print("in waitToProceed() - entered sync block");
18. //while循環判斷，這裏不用if的原因是為了防止早期通知
19. while ( okToProceed == false ) {
20. print("in waitToProceed() - about to wait()");
21. proceedLock.wait();
22. print("in waitToProceed() - back from wait()");
23. }
25. print("in waitToProceed() - leaving sync block");
26. }
28. print("in waitToProceed() - leaving");
29. }
31. public void proceed() {
32. print("in proceed() - entered");
34. synchronized ( proceedLock ) {
35. print("in proceed() - entered sync block");
36. //通知之前，將其設置為true，這樣即使出現通知遺漏的情況，也不會使線程在wait出阻塞
37. okToProceed = true;
38. print("in proceed() - changed okToProceed to true");
39. proceedLock.notifyAll();
40. print("in proceed() - just did notifyAll()");
42. print("in proceed() - leaving sync block");
43. }
45. print("in proceed() - leaving");
46. }
48. private static void print(String msg) {
49. String name = Thread.currentThread().getName();
50. System.out.println(name + ": " + msg);
51. }
53. public static void main(String[] args) {
54. final MissedNotifyFix mnf = new MissedNotifyFix();
56. Runnable runA = new Runnable() {
57. public void run() {
58. try {
59. //休眠1000ms，大於runB中的500ms，
60. //是為了後調用waitToProceed，從而先notifyAll，後wait，
61. Thread.sleep(1000);
62. mnf.waitToProceed();
63. } catch ( InterruptedException x ) {
64. x.printStackTrace();
65. }
66. }
67. };
69. Thread threadA = new Thread(runA, "threadA");
70. threadA.start();
72. Runnable runB = new Runnable() {
73. public void run() {
74. try {
75. //休眠500ms，小於runA中的1000ms，
76. //是為了先調用proceed，從而先notifyAll，後wait，
77. Thread.sleep(500);
78. mnf.proceed();
79. } catch ( InterruptedException x ) {
80. x.printStackTrace();
81. }
82. }
83. };
85. Thread threadB = new Thread(runB, "threadB");
86. threadB.start();
88. try {
89. Thread.sleep(10000);
90. } catch ( InterruptedException x ) {}
92. print("about to invoke interrupt() on threadA");
93. threadA.interrupt();
94. }
95. }

執行結果如下：

註意代碼中加了註釋的部分，在threadB進行通知之前，先將okToProceed置為true，這樣如果threadA將通知遺漏，那麽就不會進入while循環，也便不會執行wait方法，線程也就不會阻塞。如果通知沒有被遺漏，wait方法返回後，okToProceed已經被置為true，下次while循環判斷條件不成立，便會退出循環。

這樣，通過標誌位和wait、notifyAll的配合使用，便避免了通知遺漏而造成的阻塞問題。

總結：在使用線程的等待/通知機制時，一般都要配合一個boolean變量值（或者其他能夠判斷真假的條件），在notify之前改變該boolean變量的值，讓wait返回後能夠退出while循環（一般都要在wait方法外圍加一層while循環，以防止早期通知），或在通知被遺漏後，不會被阻塞在wait方法處。這樣便保證了程序的正確性。

轉：【Java並發編程】之十一：線程間通信中notify通知的遺漏（含代碼）