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

From　a　user　perspective；　it　would　seem　obvious　to　call　the　method　IncrementCounter（）
directly　from　the　other　thread　（_thread）。　However；　hidden　in　the　implementation　of　Invoke（）
is　a　producer/consumer　implementation。　The　producer　is　the　Invoke（）　method；　which　adds　a
delegate　that　needs　to　be　called　to　a　queue。　The　consumer　is　the　Windows。Forms。Form　class；　which
periodically　checks　its　Invoke（）　queue　and　executes　the　delegates　contained　within。　
In　a　nutshell；　a　producer/consumer　implementation　is　nothing　more　than　a　handoff　of
information　from　one　thread　to　another　thread。　This　is　effective　because　the　producer　and
consumer　are　separate　and　manage　their　own　concerns。　The　only　mon　information
between　the　producer　and　consumer　is　a　queue；　or　list；　which　is　synchronized　and　contains
information　of　interest　to　both　the　producer　and　consumer。　
Implementing　a　Generic　Producer/Consumer　Architecture　
The　architecture　implemented　by　Windows。Forms　is　elegant　and　self…containing。　You　can　imple
ment　a　generic　producer/consumer　architecture　using　a　delegate；　as　shown　in　the　following
source　code。　In　this　case；　we　use　the　System。Action　class；　which　encapsulates　a　Sub　that　doesn’t
take　any　parameters　（it　is　shorthand　for Public　Delegate　Sub　Action（））。　
…………………………………………………………Page　387……………………………………………………………
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　365　
Imports　System。Threading　
Class　ThreadPoolProducerConsumer　
Private　_queue　As　Queue（Of　Action）　=　New　Queue（Of　Action）（）　
Private　Sub　QueueProcessor（Byval　obj　As　Object）
Monitor。Enter（_queue）　
Do　While　_queue。Count　=　0　
Monitor。Wait（_queue；　…1）　
Loop　
Dim　action　As　Action　=　_queue。Dequeue（）　
Monitor。Exit（_queue）　
ThreadPool。QueueUserWorkItem（AddressOf　QueueProcessor）　
action（）　
End　Sub　
Public　Sub　New（）　
ThreadPool。QueueUserWorkItem（AddressOf　QueueProcessor）　
End　Sub　
Public　Sub　Invoke（ByVal　toExec　As　Action）　
Monitor。Enter（_queue）　
_queue。Enqueue（toExec）　
Monitor。Pulse（_queue）　
Monitor。Exit（_queue）　
End　Sub　
End　Class　
ThreadPoolProducerConsumer　has　a　single　public　method；　Invoke（）；　which　is　used　in　the
same　fashion　as　the　Windows。Forms　Invoke（）　method。　What　makes　the　generic　producer/consumer
work　is　its　use　of　the　Monitor　synchronization　class。
To　understand　how　Monitor　works　in　the　producer/consumer　context；　consider　the　overall
producer/consumer　implementation。　The　consumer　thread　（QueueProcessor（））　executes
constantly；　waiting　for　items　in　the　queue　（_queue）。　To　check　the　queue；　the　Monitor。Enter（）
method　is　called；　which　says；　“I　want　exclusive　control　for　a　code　block　that　ends　with　the　method
call　Monitor。Exit（）。”　To　check　the　queue；　a　Do　While　loop　is　started。　The　loop　waits　until　there
is　something　in　the　queue。　The　thread　could　execute　constantly；　waiting　for　something　to　be
added；　but　while　the　thread　is　looping；　it　has　control　of　the　lock。　This　means　a　producer　thread
cannot　add　anything　to　the　queue。　
The　consumer　needs　to　give　up　the　lock；　but　also　needs　to　check　if　anything　is　available　in
the　queue。　The　solution　is　to　call　Monitor。Wait（）；　which　causes　the　consumer　thread　to　release
the　lock　and　say；　“Hey；　I’m　giving　up　the　lock　temporarily　until　somebody　gives　me　a　signal　to
continue　processing。”　When　the　consumer　thread　releases　its　lock　temporarily；　it　goes　to　sleep
waiting　for　a　pulse。　
…………………………………………………………Page　388……………………………………………………………
366 CH　AP　T　E　R 1　3 ■ L　E　A　R　N　I　N　G A　B　OU　T M　U　L　T　I　TH　R　E　A　DI　N　G　
The　producer　thread　（Invoke（））　also　enters　a　protected　block　using　the　Monitor。Enter（）
method。　Within　the　protected　block；　an　item　is　added　to　the　queue　using　the　Enqueue（）　method。
Because　an　item　has　been　added　to　the　queue；　the　producer　thread　sends　a　signal　using　the
Monitor。Pulse（）　method　to　indicate　an　item　is　available。　This　will　cause　the　thread　that　gave
up　the　lock　temporarily　（the　consumer　thread）　to　wake　up。　However；　the　consumer　thread
executes　when　the　producer　thread　calls　Monitor。Exit（）。　Until　then；　the　consumer　thread　is　in
ready…to…execute　mode。　
In　the　simplest　case　of　this　implementation；　a　single　thread　would　constantly　execute
QueueProcessor（）。　An　optimization　is　to　create　and　use　a　thread　pool。　A　thread　pool　is　a　collec
tion　of　ready…to…execute　threads。　As　tasks　arrive；　threads　are　taken　from　the　pool　and　used　to
execute　the　tasks。　Once　the　thread　has　pleted　executing；　it　is　returned　to　the　thread　pool　in
ready…to…execute　mode。　In　the　ThreadPoolProducerConsumer　constructor；　the　method　ThreadPool。　
QueueUserWorkItem（）　uses　thread　pooling　to　execute　the　method　QueueProcessor（）。　In　the
implementation　of　QueueProcessor（）；　the　method　ThreadPool。QueueUserWorkItem（）　is　called
again　before　calling　the　delegate。　The　result　is　that　one　thread　is　always　waiting　for　an　item
in　the　queue；　but　there　may　be　multiple　threads　executing　concurrently；　processing　items　from
the　queue。　
Using　the　generic　producer/consumer　is　nearly　identical　to　using　the　Windows。Forms
Invoke（）　method。　The　following　is　a　sample　implementation。　
Imports　System。Threading　
Public　Class　TestProducerConsumer
Delegate　Sub　TestMethod（）　
Sub　Method（）
Console。WriteLine（〃Processed　in　thread　id　（〃　&　_