Visual Basic.NET How to Program (PDF)

604 Multithreading Chapter 14
from the shared buffer and then displays the data. We display in the program’s output the
values that the producer writes (produces) and that the consumer reads (consumes).
Figure 14.8 demonstrates a producer and a consumer accessing a single shared cell
(Integer variable mBuffer, Fig. 14.5 line 9) of memory without any synchronization.
Both the consumer and the producer threads access this single cell: The producer thread
writes to the cell, whereas the consumer thread reads from it. We would like each value that
the producer thread writes to the shared cell to be consumed exactly once by the consumer
thread. However, the threads in this example are not synchronized. Therefore, data can be
lost if the producer places new data into the slot before the consumer consumes the previous
data. In addition, data can be incorrectly repeated if the consumer consumes data again
before the producer produces the next item. To illustrate these possibilities, the consumer
thread in the following example keeps a total of all the values it reads. The producer thread
produces values from 1 to 4. If the consumer reads each value once and only once, the total
would be 10. However, if students execute this program several times, they will see that the
total is rarely, if ever, 10. To emphasize our point, the producer and consumer threads in
the example each sleep for random intervals of up to three seconds between performing
their tasks. Thus, we do not know exactly when the producer thread will attempt to write a
new value, nor do we know when the consumer thread will attempt to read a value.
The program consists of module modSharedCell (Fig. 14.8) and three classes—
CHoldIntegerUnsynchronized (Fig. 14.5), CProducer (Fig. 14.6) and CConsumer
(Fig. 14.7).
Class CHoldIntegerUnsynchronized (Fig. 14.5) consists of instance variable
mBuffer (line 9) and property Buffer (lines 12–28), which provides Get and Set
accessors. Property Buffer’s accessors do not synchronize access to instance variable
mBuffer. Note that each accessor uses class Thread’s Shared property Current-
Thread to obtain a reference to the currently executing thread and then uses that thread’s
property Name to obtain the thread’s name.
1 ' Fig. 14.5: HoldIntegerUnsynchronized.vb
2 ' Definition of a shared integer without synchronization mechanisms.
3
4 Imports System.Threading
5
6 Public Class CHoldIntegerUnsynchronized
7
8 ' buffer shared by producer and consumer threads
9 Private mBuffer As Integer = -1
10
11 ' property Buffer
12 Property Buffer() As Integer
13
14 Get
15 Console.WriteLine(Thread.CurrentThread.Name & _
16 " reads " & mBuffer)
17
18 Return mBuffer
19 End Get
Fig. 14.5 Unsynchronized shared Integer buffer (part 1 of 2).