《VB2008从入门到精通(PDF格式英文版)》第170章

Monitor。Wait（elements；　1000）　
Loop　
items　=　elements。ToArray（）　
Monitor。Exit（elements）　
Dim　item　As　Integer　
For　Each　item　In　items　
Console。WriteLine（〃Item　（〃　&　item　&　〃）〃）　
Thread。Sleep（1000）　
Next　
End　Sub　
Sub　Task2（）　
Monitor。Enter（elements）　
elements。Add（30）　
Monitor。Pulse（elements）　
Monitor。Exit（elements）　
End　Sub　
The　bolded　code　lines　are　the　new　pieces　that　use　the　Monitor　type。　In　the　definition　of　the
first　thread　to　get　the　lock；　the　Monitor。Enter（）　method　is　called　with　the　parameter　elements；
which；　as　in　the　earlier　SyncLock　example；　defines　the　lock　reference　handle。　Once　the　lock　has
been　acquired；　the　thread　checks　to　see　if　the　list　count　is　greater　or　equal　to　3。　If　the　counter　is
less　than　3；　the　Monitor。Wait（）　method　is　called。　The　behavior　of　Monitor。Wait（）　is　similar　to
Thread。Sleep（）；　except　that　the　Monitor　lock　is　given　up。
Releasing　the　lock　is　a　unique　feature　of　a　Monitor。　The　lock　is　given　up　only　during　the
time　that　the　caller　is　in　Monitor。Wait（）。　When　the　Monitor。Wait（）　method　returns；　the　lock　is
acquired　again。　The　code　says　that　the　thread　is　reawakened　after　1　second。　After　that　second；
the　thread　does　not　have　the　lock　and　needs　to　wait　before　it　can　acquire　the　lock。　If　another
thread　is　holding　onto　the　lock　for　a　long　time；　it　could　take　a　while　to　get　the　lock　back　again。　
Another　way　for　the　Monitor。Wait（）　method　to　awaken　is　if　a　signal　is　sent　by　another
thread。　The　code　for　the　second　thread　uses　Enter（）　and　Exit（）；　but　also　Pulse（）。　The　Monitor。　
Pulse（）　method　triggers　a　signal　that　awakens　the　first　thread；　but　the　first　thread　will　execute
only　after　the　second　thread　has　released　control　of　the　lock。
The　big　advantages　of　a　Monitor　in　parison　to SyncLock　are　that　the　Monitor　can　be
used　anywhere　in　the　code　and　that　the　Monitor　will　release　a　lock　while　waiting　for　an　answer。
You　would　use SyncLock　when　you　want　to　control　access　to　a　block　of　code。　If　the　access　goes
beyond　method　boundaries；　then　it　is　preferable　to　use　Monitor。　It　is　not　that　you　could　not　use
a　SyncLock　that　spanned　boundaries；　but　if　you　need　to　add　code　that　could　produce　a　dead
lock；　it　is　easier　to　control　that　code　using　a　Monitor。　
Now　that　we’ve　covered　the　fundamentals　of　multithreading；　the　next　sections　focus　on
more　advanced　threading　architectures—reader/writer　and　producer/consumer—and　using
asynchronous　calls。　
…………………………………………………………Page　381……………………………………………………………
C　HA　P　TE　R 1　3 ■ L　E　AR　N　IN　G AB　O　U　T M　U　L　T　IT　HR　E　AD　IN　G　359　
Implementing　a　Reader/Writer
Threaded　Architecture　
The　reader/writer　threaded　architecture　is　based　on　the　idea　that　if　one　thread　is　reading　and
another　thread　would　like　to　read　as　well；　why　not　let　it？　However；　if　one　thread　wants　to　write；
then　only　that　thread　can　write。　In　other　words；　multiple　threads　are　allowed　to　read　data
simultaneously；　but　to　write；　a　thread　must　have　an　exclusive　lock。　
implements　a　System。Threading。ReaderWriterLock　class；　which　contains　the　reader/　
writer　functionality。　This　class　is　like　a　Monitor；　in　that　it　gives　you　the　control　to　manage　how
data　is　accessed　but　does　not　determine　what　you　are　accessing。　The　ReaderWriterLock　type
has　a　number　of　methods　and　properties。　The　most　important　ones　are　listed　in　Table　13…1。　
Table　13…1。　Important　ReaderWriterLock　Methods　
Method Description　
AcquireReaderLock（） Acquires　a　reader　lock。　Multiple　threads　can　acquire　a
reader　lock。　
AcquireWriterLock（） Acquires　a　writer　lock。　Only　a　single　thread　can　acquire
a　writer　lock。　
DowngradeFromWriterLock（） Converts　a　writer　lock　into　a　reader　lock。　Using　this
method　avoids　the　need　to　call　ReleaseWriterLock（）
and　AcquireReaderLock（）。　
UpgradeToWriterLock（） Converts　a　reader　lock　into　a　writer　lock。　Using　this
method　avoids　the　need　to　call　ReleaseReaderLock（）
and　AcquireWriterLock（）。
ReleaseLock（） Releases　all　locks；　regardless　how　many　times　you　have
called　to　acquire　the　reader　or　writer　locks。　
ReleaseReaderLock（） Decrements　the　reader　lock　a　single　count。　To　pletely
release　a　reader　lock；　you　need　to　make　sure　the　number
of　times　you　called　ReleaseReaderLock（）　is　equal　to　the
number　of　times　you　called　AcquireReaderLock（）。　
ReleaseWriterLock（） Decrements　the　writer　lock　a　single　count。　To　pletely
release　a　reader　lock；　you　need　to　make　sure　the　number
of　times　you　called　ReleaseWriterLock（）　is　equal　to　the
number　of　times　you　called　AcquireWriterLock（）。　
Let’s　look　at　a　collection　example　that　ha