Go: "Java concurrency Programming" 12: Early Notification issues notifyall in inter-thread communication (with code)

Reprint Please specify source:http://blog.csdn.net/ns_code/article/details/17229601

If a thread waits for a notification, but the thread waits for a condition that is not satisfied, the thread is given an early notification, and if the condition is satisfied for a short period of time, but changes again quickly and becomes no longer satisfied, an early notification will also occur. This behavior sounds strange, and the following is an example program to illustrate the problem.

Quite simply, two threads wait for the element in the list to be deleted while the other line is impersonating to add items to it. The code is as follows:

[Java]View PlainCopy

2. Import java.util.*;
6. Public class Earlynotify extends Object {
8. private list List;
12. Public earlynotify () {
14. List = Collections.synchronizedlist (new LinkedList ());
16. }
20. Public String RemoveItem () throws interruptedexception {
22. Print ("in RemoveItem ()-entering");
26. synchronized (list) {
28. if (List.isEmpty ()) { //Here is a danger with an if statement
30. Print ("in RemoveItem ()-About to wait ()");
32. List.wait ();
34. Print ("in RemoveItem ()-Do with Wait ()");
36. }
40. //Delete element
42. String item = (string) list.remove (0);
46. Print ("in RemoveItem ()-leaving");
48. return item;
50. }
52. }
56. public void AddItem (String item) {
58. Print ("in AddItem ()-entering");
60. synchronized (list) {
62. //Add element
64. List.add (item);
66. Print ("in AddItem ()-just added: '" + Item + "'");
70. //Add, notify all threads
72. List.notifyall ();
74. Print ("in AddItem ()-Just notified");
76. }
78. Print ("in AddItem ()-leaving");
80. }
84. private static void print (String msg) {
86. String name = Thread.CurrentThread (). GetName ();
88. SYSTEM.OUT.PRINTLN (name + ":" + msg);
90. }
94. public static void Main (string[] args) {
96. final earlynotify en = new earlynotify ();
100. Runnable RunA = new Runnable () {
102. public Void Run () {
104. try {
106. String item = En.removeitem ();
108. Print ("in Run ()-returned: '" +
110. Item + "'");
112. } catch (Interruptedexception ix) {
114. Print ("interrupted!");
116. } catch (Exception x) {
118. Print ("threw an Exception!!!  \ n "+ x);
120. }
122. }
124. };
128. Runnable Runb = new Runnable () {
130. public Void Run () {
132. En.additem ("hello!");
134. }
136. };
140. try {
142. //Start the first thread to delete an element
144. Thread threadA1 = new Thread (RunA, "threadA1");
146. Threada1.start ();
150. Thread.Sleep (500);
154. //Start the second thread to delete an element
156. Thread threadA2 = new Thread (RunA, "threadA2");
158. Threada2.start ();
162. Thread.Sleep (500);
164. //Start thread that adds elements
166. Thread threadb = new Thread (Runb, "threadb");
168. Threadb.start ();
172. Thread.Sleep (10000); //wait ten seconds
176. Threada1.interrupt ();
178. Threada2.interrupt ();
180. } catch (Interruptedexception x) {}
182. }
184. }

The results of the implementation are as follows:

Analysis: First start threada1,threada1 call Wait () in RemoveItem () to release the object lock on the list. After 500ms, start threada2,threada2 call RemoveItem (), get the object lock on the list, and find that the list is empty, blocking at the wait () method, freeing the object lock on the list. After 500ms, start threadb, call AddItem, get the object lock on the list, add an element to the list, and notify all threads with Notifyall.

ThreadA1 and ThreadA2 both return from Wait (), wait for an object lock on the list object, and attempt to remove the added element from the listing, which can cause trouble and only one of the operations succeeds. Assuming that threadA1 acquires the object lock on the list and deletes the element successfully, when exiting the synchronized block, it frees the object lock on the list, and ThreadA2 acquires the object lock on the list, and continues to delete the elements in the list. But the list is empty, which throws indexoutofboundsexception.

To avoid this, simply change the IF statement of the wait perimeter to a while loop, so that when the list is empty, the thread will continue to wait instead of executing the code to delete the elements in the list.

The result of the modified execution is as follows:

Summary: When using the thread's wait/notification mechanism, it is generally necessary to call the wait () method in the while loop, so that the while loop exits when the condition is met, which generally also uses a Boolean variable (or any other condition that can determine the true or false). As in this article, List.isEmpty ()), when the condition of the while loop is met, enters the while loop, executes the wait () method, does not satisfy the condition of the while loop, and executes the subsequent code.

Go: "Java concurrency Programming" 12: Early Notification issues notifyall in inter-thread communication (with code)