Java How to Program Fourth Edition - DCC

Chapter 15 Multithreading 849
Monitor objects maintain a list of all threads waiting to enter the monitor object to execute
synchronized methods. A thread is inserted in the list and waits for the object if
that thread calls a synchronized method of the object while another thread is already
executing in a synchronized method of that object. A thread also is inserted in the list
if the thread calls wait while operating inside the object. However, it is important to distinguish
between waiting threads that blocked because the monitor was busy and threads
that explicitly called wait inside the monitor. Upon completion of a synchronized
method, outside threads that blocked because the monitor was busy can proceed to enter the
object. Threads that explicitly invoked wait can proceed only when notified via a call by
another thread to notify or notifyAll. When it is acceptable for a waiting thread to
proceed, the scheduler selects the thread with the highest priority.
Common Programming Error 15.2
It is an error if a thread issues a wait, a notify or a notifyAll on an object without
having acquired a lock for the object. This causes an IllegalMonitorState-
Exception. 15.2
15.6 Producer/Consumer Relationship without Thread
Synchronization
In a producer/consumer relationship, a producer thread calling a produce method may
see that the consumer thread has not read the last message from a shared region of memory
called a buffer, so the producer thread will call wait. When a consumer thread reads
the message, it will call notify to allow a waiting producer to proceed. When a consumer
thread enters the monitor and finds the buffer empty, it calls wait. A producer
finding the buffer empty writes to the buffer, then calls notify so a waiting consumer
can proceed.
Shared data can get corrupted if we do not synchronize access among multiple threads.
Consider a producer/consumer relationship in which a producer thread deposits a sequence
of numbers (we use 1, 2, 3, …) into a slot of shared memory. The consumer thread reads
this data from the shared memory and prints it. We print what the producer produces as it
produces it and what the consumer consumes as it consumes it. The program of Fig. 15.4–
Fig. 15.7 demonstrates a producer and a consumer accessing a single shared cell of memory
(int variable sharedInt in Fig. 15.6) without any synchronization. The threads are not
synchronized, so data can be lost if the producer places new data into the slot before the
consumer consumes the previous data. Also, data can be “doubled” if the consumer consumes
data again before the producer produces the next item. To show these possibilities,
the consumer thread in this example keeps a total of all the values it reads. The producer
thread produces values from 1 to 10. If the consumer reads each value produced only once,
the total would be 55. However, if you execute this program several times, you will see that
the total is rarely, if ever, 55.
The program consists of four classes—ProduceInteger (Fig. 15.4), ConsumeInteger
(Fig. 15.5), HoldIntegerUnsynchronized (Fig. 15.6) and
SharedCell (Fig. 15.7).
Class ProduceInteger (Fig. 15.4)—a subclass of Thread—consists of instance
variable sharedObject (line 4), a constructor (lines 7–11) and a run method (lines 15–
37). The constructor initializes instance variable sharedObject (line 10) to refer to the