Visual Basic.NET How to Program (PDF)

Chapter 14 Multithreading 617
The Get and Set accessors are implemented similarly. As in Fig. 14.7, the consumer
thread (Fig. 14.11)performs the tasks specified in the consumer object’s Consume
method. The consumer thread gets the value of the CHoldIntegerSynchronized
object’s Buffer property (Fig. 14.11, line 26) by invoking the Get accessor at Fig. 14.9,
lines 16–61. In Fig. 14.9, line 19 invokes Monitor method Enter to acquire the lock on
the CHoldIntegerSynchronized object.
The If structure in lines 23–31 determines whether occupiedBufferCount is
0. If this condition is True, lines 24–25 output a message indicating that the consumer
thread tried to read a value, and lines 27–28 invoke method DisplayState to output
another message indicating that the buffer is empty and that the consumer thread waits.
Line 30 invokes Monitor method Wait to place the calling thread (i.e., the consumer)
in the WaitSleepJoin state for the CHoldIntegerSynchronized object and releases
the lock on the object. Now, another thread can invoke an accessor method of the
CHoldIntegerSynchronized object’s Buffer property.
The consumer thread object remains in the WaitSleepJoin state until the thread is
notified that it can proceed—at which point the thread returns to the Started state and
waits for the system to assign a processor to the thread. When the thread reenters the Running
state, the thread implicitly reacquires the lock on the CHoldIntegerSynchronized
object, and the Get accessor continues executing with the next statement after
Wait. Line 35 decrements occupiedBufferCount to indicate that the shared buffer
now is empty (i.e., a consumer cannot read the value, but a producer can place another
value into the shared buffer). Lines 37–38 output a line to the command window specifying
the value that the consumer is reading, and line 42 invokes Monitor method
Pulse with the CHoldIntegerSynchronized object as an argument. If there are
any waiting threads in that object’s SyncBlock, the first waiting thread enters the Started
state, indicating that the thread can attempt its task again as soon as the thread is assigned
a processor. The Pulse method returns immediately. Line 55 creates a copy of
mBuffer before releasing lock. It is possible that the producer could be assigned the
processor immediately after the lock is released (line 58) and before the Return statement
executes (line 60). In this case, the producer would assign a new value to mBuffer
before the Return statement returns the value to the consumer. Thus, the consumer
would receive the new value. By, making a copy of mBuffer and returning the copy,
we ensure that the consumer receives the proper value. Line 58 invokes Monitor
method Exit to release the lock on the CHoldIntegerSynchronized object, and
the Get accessor returns bufferCopy to its caller.
Study the outputs depicted in Fig. 14.12. Observe that every Integer produced is
consumed exactly once—no values are lost, and no values are consumed more than once.
This occurs because the producer and consumer cannot perform tasks unless it is "their
turn." The producer must go first; the consumer must wait if the producer has not produced
a value since the consumer last consumed; and the producer must wait if the consumer
has not yet consumed the value that the producer most recently produced. Execute
this program several times to confirm that every Integer produced is consumed
exactly once.
In the first and second sample outputs, notice the lines indicating when the producer
and consumer must wait to perform their respective tasks. In the third sample output,
notice that the producer and consumer were able to perform their tasks without waiting.