AhmadLang / Java, How To Program, 2004

Common Programming Error 23.2

It is an error if a thread issues an await, a signal, or a signalAll on a condition variable without having acquired the lock for that condition variable. This causes an

IllegalMonitorStateException.

23.8), UnsynchronizedBuffer (Fig. 23.9) and SharedBufferTest (Fig. 23.10). Interface Buffer declares methods set and get that a Buffer must implement to enable the Producer tHRead to place a value in the Buffer and the Consumer tHRead to retrieve a value from the Buffer. We will see the implementation of this interface in Fig. 23.9.

Figure 23.7. Producer represents the producer thread in a producer/consumer relationship.

(This item is displayed on page 1066 in the print version)

5public class Producer implements Runnable

6{

7

8

9

10// constructor

11public Producer( Buffer shared )

12{

13sharedLocation = shared;

14} // end Producer constructor

15

16// store values from 1 to 10 in sharedLocation

17public void run()

18{

19int sum = 0;

20

21

22

23

24

25

26

27

28

29} // end try

30// if sleeping thread interrupted, print stack trace

31catch ( InterruptedException exception )

32{

34} // end catch

35} // end for

36

37System.out.printf( "\n%s\n%s\n", "Producer done producing.",

38"Terminating Producer." );

39} // end method run

40} // end class Producer

Figure 23.8. Consumer represents the consumer thread in a producer/consumer relationship.

(This item is displayed on page 1067 in the print version)

5public class Consumer implements Runnable

6{

7

8

9

10

1 // Fig 23.10: SharedBufferTest.java

2 // Application shows two threads manipulating an unsynchronized buffer.

3import java.util.concurrent.ExecutorService;

4import java.util.concurrent.Executors;

5

6public class SharedBufferTest

7{

8public static void main( String[] args )

9{

10// create new thread pool with two threads

11ExecutorService application = Executors.newFixedThreadPool( 2 );

13// create UnsynchronizedBuffer to store ints

14Buffer sharedLocation = new UnsynchronizedBuffer();

16System.out.println( "Action\t\tValue\tProduced\tConsumed" );

17System.out.println( "------\t\t-----\t--------\t--------\n" );

19 // try to start producer and consumer giving each of them access

20// to sharedLocation

21try

22{

23application.execute( new Producer( sharedLocation ) );

24application.execute( new Consumer( sharedLocation ) );

25} // end try

26catch ( Exception exception )

27{

28exception.printStackTrace();

29} // end catch

30

31application.shutdown(); // terminate application when threads end

32} // end main

33} // end class SharedBufferTest

Terminating Producer.

Class Producer (Fig. 23.7) implements the Runnable interface, allowing it to be executed in a separate thread. The constructor (lines 1114) initializes Buffer reference sharedLocation with an object created in main (line 14 of Fig. 23.10) and passed to the constructor in the parameter shared. As we will see, this is an UnsynchronizedBuffer object that implements interface Buffer without synchronizing access to the shared object. The Producer tHRead in this program executes the tasks specified in method run (lines 1739). Each iteration of the loop (lines 2135) invokes THRead method sleep (line 25) to place the Producer tHRead into the timed waiting state for a random time interval between 0 and 3 seconds. When the thread awakens, line 26 passes the value of control variable count to the Buffer object's set method to set the shared buffer's value. Line 27 keeps a total of all the values produced so far and line 28 outputs that value. When the loop completes, lines 3738 display a message indicating that the thread has finished producing data and is terminating. Next, method run terminates which indicates that the Producer completed its task. It is important to note that any method called from a thread's run method (e.g., Buffer method set) executes as part of that thread of execution. In fact, each thread has its own method call stack. This fact becomes important in Section 23.7 when we add synchronization to the producer/consumer relationship.

Class Consumer (Fig. 23.8) also implements interface Runnable, allowing the Consumer to be executed concurrently with the Producer. The constructor (lines 1114) initializes Buffer reference sharedLocation with an object that implements the Buffer interface created in main (Fig. 23.10) and passed to the constructor as the parameter shared. As we will see, this is the same UnsynchronizedBuffer object that is used to initialize the Producer objectthus, the two threads share the same object. The Consumer thread in this program performs the tasks specified in method run (lines 1739). The loop at lines 2135 loops ten times. Each iteration of the loop invokes THRead method sleep (line 26) to put the Consumer thread into the timed waiting state for between 0 and 3 seconds. Next, line 27 uses the Buffer's get method to retrieve the value in the shared buffer, then adds the value to variable sum. Line 28 displays the total of all the values consumed so far. When the loop completes, lines 3738 display a line indicating the sum of the consumed values. Then method run terminates, which indicates that the Consumer completed its task. Once both threads enter the terminated state, the program ends.

[Page 1066]

[Page 1067]

[Note: We use method sleep in method run of the Producer and Consumer classes to emphasize the fact that in multithreaded applications, it is unpredictable when each thread will perform its task and for how long it will perform the task when it has a processor. Normally, these thread-scheduling issues are the job of the computer's operating system and therefore beyod the control of the Java developer. In this program, our thread's tasks are quite simplefor the Producer, write the values 1 to 10 to the buffer, and for the Consumer, read 10 values from the buffer and add each value to variable sum. Without the sleep method call, and if the Producer executes first, given today's phenomenally fast processors, the Producer would likely complete its task before the Consumer gets a chance to execute. If the Consumer executes first, it would likely consume -1 ten times, then terminate before the Producer could produce

the first real value.]

[Page 1068]

Class UnsynchronizedBuffer (Fig. 23.9) implements interface Buffer (line 4). An object of this class is shared between the Producer and the Consumer. Line 6 declares instance variable buffer and initializes it with the value -1. This value is used to demonstrate the case in which the Consumer attempts to consume a value before the Producer ever places a value in buffer. Methods set (lines 913) and get (lines 1620) do not synchronize access to field buffer. Method set simply assigns its argument to buffer (line 12), and method get simply returns the value of buffer (line 19).

Class SharedBufferTest contains method main (lines 832), which launches the application. Line 11 creates an ExecutorService with two threadsone to execute the Producer and one to execute the Consumer. Line 14 creates an UnsynchronizedBuffer object and assigns its reference to Buffer variable sharedLocation. This object stores the data that will be shared between the Producer and Consumer threads. Lines 2324 create and execute the Producer and Consumer. Note that the Producer and Consumer constructors are each passed the same Buffer object (sharedLocation), so each object is initialized with a reference to the same Buffer. These lines also implicitly launch the threads and call each Runnable's run method. Finally, line 31 calls method shutdown so that the application can terminate when the Producer and Consumer threads complete their tasks. When method main terminates (line 32), the main thread of execution enters the terminated state.

Recall from the overview of this example that we would like the Producer thread to execute first and every value produced by the Producer to be consumed exactly once by the Consumer. However, when we study the first output of Fig. 23.10, we see that the Producer writes a value three times before the Consumer reads its first value (3). Therefore, the values 1 and 2 are lost. Later, the values 5, 6 and 9 are lost, while 7 and 8 are read twice and 10 is read four times. So the first output produced an incorrect total of 77, instead of a correct total of 55. In the second output, note that the Consumer reads before the Producer ever writes a value. Also note that the Consumer has already read five times before the Producer writes the value 2. Meanwhile, the values 5, 7, 8, 9 and 10 are all lost. An incorrect output of 19 is produced. (Lines in the output where the Producer or Consumer has acted out of order are highlighted.) This example clearly demonstrates that access to a shared object by concurrent threads must be controlled carefully, for otherwise a program may produce incorrect results.

[Page 1069]

To solve the problems of lost and duplicated data, Section 23.7 presents an example in which we use a Lock and Condition methods await and signal to synchronize access to the code that manipulates the shared object, guaranteeing that each and every value will be processed once and only once. When a thread acquires a lock, no other threads can acquire that same lock until the original thread releases it.

[Page 1071]

23.7. Producer/Consumer Relationship with Synchronization

The application in Fig. 23.11 and Fig. 23.12 demonstrates a producer and a consumer accessing a shared buffer with synchronization. In this case, the consumer correctly consumes only after the producer produces a value, and the producer correctly produces a new value only after the consumer consumes the previous value produced. We reuse interface Buffer (Fig. 23.6) and use classes Producer (Fig. 23.7 modified to remove line 28) and Consumer (Fig. 23.8 modified to remove line 28) from the example in Section 23.6. This approach enables us to demonstrate that the threads accessing the shared object are unaware that they are being synchronized. The code that performs the synchronization is placed in the set and get methods of class SynchronizedBuffer (Fig. 23.11), which implements interface Buffer (line 7). Thus, the Producer's and Consumer's run methods simply call the shared object's set and get methods, as in the example in Section 23.6.

[Page 1073]

Figure 23.11. SynchronizedBuffer synchronizes access to a shared integer.

(This item is displayed on pages 1071 - 1073 in the print version)

1 // Fig. 23.11: SynchronizedBuffer.java

2 // SynchronizedBuffer synchronizes access to a single shared integer.

3import java.util.concurrent.locks.Lock;

4import java.util.concurrent.locks.ReentrantLock;

5import java.util.concurrent.locks.Condition;

6

7public class SynchronizedBuffer implements Buffer

8{

9// Lock to control synchronization with this buffer

10private Lock accessLock = new ReentrantLock();

11

12// conditions to control reading and writing

13private Condition canWrite = accessLock.newCondition();

14private Condition canRead = accessLock.newCondition();

19// place int value into buffer

20public void set( int value )

21{

22accessLock.lock(); // lock this object

24// output thread information and buffer information, then wait

25try

26{

27// while buffer is not empty, place thread in waiting state

28while ( occupied )

29{

37// indicate producer cannot store another value

38// until consumer retrieves current buffer value

39occupied = true;

44canRead.signal();

45} // end try

46catch ( InterruptedException exception )

47{

48exception.printStackTrace();

49} // end catch

50finally

51{

52accessLock.unlock(); // unlock this object

53} // end finally

54} // end method set

55

56// return value from buffer

57public int get()

58{

59int readValue = 0; // initialize value read from buffer

60accessLock.lock(); // lock this object

61

62// output thread information and buffer information, then wait

63try

64{

65// while no data to read, place thread in waiting state

66while ( !occupied )

67{

73// indicate that producer can store another value

74// because consumer just retrieved buffer value

75occupied = false;

76

77readValue = buffer; // retrieve value from buffer

78displayState( "Consumer reads " + readValue );

79

80// signal thread waiting for buffer to be empty

81canWrite.signal();

82} // end try

83// if waiting thread interrupted, print stack trace

84catch ( InterruptedException exception )

85{

86exception.printStackTrace();

87} // end catch

88finally

89{

90accessLock.unlock(); // unlock this object

91} // end finally

92

93return readValue;

94} // end method get

96// display current operation and buffer state

97public void displayState( String operation )

98{

99System.out.printf( "%-40s%d\t\t%b\n\n", operation, buffer,

100occupied );

101} // end method displayState

102} // end class SynchronizedBuffer

Figure 23.12. SharedBufferTest2 sets up a producer/consumer application that uses a synchronized buffer.

(This item is displayed on pages 1075 - 1076 in the print version)

1 // Fig 23.12: SharedBufferTest2.java

2 // Application shows two threads manipulating a synchronized buffer.

3import java.util.concurrent.ExecutorService;

4import java.util.concurrent.Executors;

5

6public class SharedBufferTest2

7{

8public static void main( String[] args )

9{

10// create new thread pool with two threads

11ExecutorService application = Executors.newFixedThreadPool( 2 );

13// create SynchronizedBuffer to store ints

14Buffer sharedLocation = new SynchronizedBuffer();

16System.out.printf( "%-40s%s\t\t%s\n%-40s%s\n\n", "Operation",

19try // try to start producer and consumer

20{

21application.execute( new Producer( sharedLocation ) );

22application.execute( new Consumer( sharedLocation ) );

23} // end try

24catch ( Exception exception )

25{

26exception.printStackTrace();

27} // end catch

28

29application.shutdown();

30} // end main

31} // end class SharedBufferTest2