VB2008从入门到精通(PDF格式英文版)-第70部分

快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 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　（〃　&　_　

　　　　　　　　　　　　　　　　　　　　　　Thread。CurrentThread。ManagedThreadId　&　〃）〃）　

　　　　　　　　　　　　　　End　Sub　



　　　　　　　　　　　　　　Public　Sub　TestSimple（）　　

　　　　　　　　　　　　　　　　　　Dim　producer　As　ThreadPoolProducerConsumer　=　_　

　　　　　　　　　　　　　　　　　　　　New　ThreadPoolProducerConsumer（）　

　　　　　　　　　　　　　　　　　　Console。WriteLine（〃Sent　in　thread　id　（〃　&　_　

　　　　　　　　　　　　　　　　　　　　　　Thread。CurrentThread。ManagedThreadId（）&　〃）〃）　

　　　　　　　　　　　　　　　　　　producer。Invoke（AddressOf　Method）　

　　　　　　　　　　　　　　End　Sub　

　　　　　　　　　　End　Class　



　　　　　　　　　　　　　　　The　TestSimple（）　method　instantiates　the　ThreadPoolProducerConsumer　type。　Then　the　　

　　　　　　　　　　Invoke（）　method　is　called　using　the　delegate　TestMethod；　which　executes　the　Method（）　method。　　



　　　　　　　　　　■Note　　The　Thread。ManagedThreadId　property　uniquely　identifies　the　managed　thread　to　which　it　belongs。　


…………………………………………………………Page　389……………………………………………………………

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　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　367　



Using　an　Asynchronous　Approach　　



Using　asynchronous　techniques　means　to　perform　a　task；　such　as　read　a　file　or　database　result；　　

and　then　rather　than　wait　for　the　results；　let　some　other　code　handle　the　results。　The　asynchro

nous　interaction　is　an　example　of　the　producer/consumer　architecture；　where　the　consumer　　

makes　a　request　of　the　producer　and　carries　on　until　it　gets　a　response　to　that　request。　

　　　　　The　asynchronous　technique　used　throughout　the　　API　is　consistent　and　is　easily　　

demonstrated　by　reading　a　file　asynchronously。　In　Chapter　10；　you　learned　how　to　read　a　file　or　　

console　stream　using　synchronous　techniques。　You　could　just　as　well　have　read　that　file　or　　

stream　asynchronously。　

　　　　　You　would　use　asynchronous　techniques　when　you　don’t　want　to　wait　around　for　the　task　　

to　plete。　To　read　a　file　asynchronously；　the　following　source　code　is　used。　



Imports　System。IO　

Imports　System。Text　



Friend　Module　TestAsynchronousFile　

　　　　Dim　data　As　Byte（）　=　New　Byte（200000）　｛｝　

　　　　Private　filename　As　String　=　〃threads。vb〃　



　　　　Public　Sub　RunAll（）　

　　　　　　　　TestAsynchronousFile。LoadFileAsynchronously（）　

　　　　End　Sub　



　　　　Private　Sub　LoadFileAsynchronously（）　

　　　　　　　　Dim　fs　As　New　FileStream（TestAsynchronousFile。filename；　FileMode。Open）　

　　　　　　　　fs。BeginRead（Data　；　0；　Data　。Length；　_　

　　　　　　　　　　　　　　　　　　　　　AddressOf　DoAsyncRead；　fs）。AsyncWaitHandle。WaitOne（）　

　　　　　End　Sub　



　　　　Sub　DoAsyncRead（ByVal　result　As　IAsyncResult）　

　　　　　　　　Dim　localFS　As　FileStream　=　DirectCast（result。AsyncState；　FileStream）　

　　　　　　　　Dim　bytesRead　As　Integer　=　localFS。EndRead（result）　

　　　　　　　　Dim　buffer　As　String　=　Encoding。ASCII。GetString（data）　

　　　　　　　　Console。WriteLine（〃Buffer　bytes　read　（〃　&　bytesRead　&　〃）〃）　

　　　　　　　　localFS。Close（）　

　　　　End　Sub　

End　Module　



　　　　　To　read　a　file；　you　need　to　open　a　file　stream；　just　as　in　Chapter　10’s　examples。　However；　　

instead　of　reading　the　data　directly；　the　BeginRead（）　method　is　called；　and　it　starts　a　read　operation。　　

What　distinguishes　the　asynchronous　operation　is　that　BeginRead（）　returns　immediately。　Think　of　　

it　as　starting　the　producer。　

　　　　　When　you　call　BeginRead（）；　the　first　three　parameters　represent　the　variable　that　contains　　

the　read　bytes。　The　first　parameter　is　the　byte　array　where　the　data　should　be　written。　The　second　　

and　third　parameters　are　the　starting　and　ending　locations　of　the　write　operation　in　the　byte　　

array。　The　fourth　parameter　to　BeginRead（）　is　the　delegate　that　will　be　called　when　the　data　　

is　ready　to　be　processed。　The　last　parameter　is　like　a　thread　parameter　and　is　assigned　to　the　　


…………………………………………………………Page　390……………………………………………………………

368　　　　　　　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　



　　　　　　　　　　　IAsyncResult。AsyncState　data　member。　IAsyncResult　is　in　the　System　namespace　and　is　there

　　　　　　　　　　　fore　part　of　the　　API。　

　　　　　　　　　　　　　　　　When　you　call　　BeginRead（）；　you　are　saying；　“Please　fill　up　as　many　bytes　as　possible　in　the　　

　　　　　　　　　　　byte　array。　When　you　have　read　the　bytes；　call　my　consumer　code。”　The　filling　of　the　array　and　　

　　　　　　　　　　　calling　of　the　consumer　code　occur　in　a　separate　thread。　

　　　　　　　　　　　　　　　　For　illustration　purposes；　the　AsyncWaitHandle。WaitOne（）　method　is　called　so　that　the　main　　

　　　　　　　　　　　calling　thread　continues　only　after　the　data　has　been　read　and　processed。　It　is　a　superfluous　　

　　　　　　　　　　　method　call；　since　doing　this　would　make　the　file…reading　behavior　resemble　a　synchronous　　

　　　　　　　　　　　operation。　

　　　　　　　　　　　　　　　　The　consumer　code　（that　is；　the　DoAsyncRead（）　method）is　executed　on　another　thread　and　　

　　　　　　　　　　　is　responsible　for　reading　all　the　bytes。　The　method　receives　an　IAsyncResult　parameter；　which　　

　　　　　　　　　　　has　an　AsyncState　property　and　is　the　value　that　we　passed　in　as　the　fifth　parameter　to　BeginRead（）　　

　　　　　　　　　　　（the　file　stream）。　DoAsyncRead（）　then　converts　this　parameter　into　a　　FileStream　and　reads　the　　

　　　　　　　　　　　remaining　bytes　from　the　stream。　The　byte　stream　is　then　converted　into　a　string　buffer。　When　　

　　　　　　　　　　　all　the　data　has　been　read；　the　file　stream　is　closed。　

　　　　　　　　　　　　　　　　When　using　this　asynchronous　approach；　you　are　really　writing　producer/consumer　code。　　

　　　　　　　　　　　The　use　of　　IAsyncResult；　BeginRead（）；　and　EndRead（）　is　quite　mon。　The　purpose　of　the　　

　　　　　　　　　　　asynchronous　interface　is　to　convert　a　synchronous　operation　into　an　asynchronous　operation。　



　　　　　　　　　　　The　Important　Stuff　to　Remember　



　　　　　　　　　　　In　this　chapter；　you　learned　the　essentials　of　using　threads　and　how　to　write　multithreaded　　

　　　　　　　　　　　code。　The　main　items　to　remember　are　as　follows：　



　　　　　　　　　　　　　　　o　　The　operating　system　assigns　time　slices　to　your　application。　



　　　　　　　　　　　　　　　o　　A　time　slice　is　a　predefined　amount　of　time　in　which　your　program　can　execute　and　has　　

　　　　　　　　　　　　　　　　　　full　control　of　the　microprocessor。　



　　　　　　　　　　　　　　　o　　To　implement　tasks　that　you　want　to　run　separately　from　the　main　program；　you　　

　　　　　　　　　　　　　　　　　　use　threads。　



　　　　　　　　　　　　　　　o　　Each　program　that　is　started　is　a　task　and　has　a　main　thread　from　which　you　can　start　　

　　　　　　　　　　　　　　　　　　other　threads。　



　　　　　　　　　　　　　　　o　　Threading　is　not　difficult　and　easily　implemented。　What　is　more　difficult　is　synchroniza

　　　　　　　　　　　　　　　　　　tion　between　the　threads。　



　　　　　　　　　　　　　　　o　　Synchronization　is　not　about　the　data；　but　about　synchronizing　access　to　code　that　　

　　　　　　　　　　　　　　　　　　modifies　data　that　is　shared。　If　your　data　is　not　shared；　you　don’t　need　synchronization。　



　　　　　　　　　　　　　　　o　　In　the　context　of　a　single　application；　you　will　use　either　the　exclusive　lock　or　the　Monitor　　

　　　　　　　　　　　　　　　　　　for　synchronization。　



　　　　　　　　　　　　　　　o　　Locking　code　slows　down　the　code。　You　should　keep　the　locks　for　the　shortest　time　possible。　



　　　　　　　　　　　　　　　o　　To　improve　throughput；　you　can　take　a　snapshot　of　the　data。　



　　　　　　　　　　　　　　　o　　Higher…level　synchronization　abstractions　are　the　reader/writer　and　producer/consumer　　

　　　　　　　　　　　　　　　　　　architectures。　


…………………………………………………………Page　391……………………………………………………………

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　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　369　



　　　　　o　　Reader/writer　locks　are　exclusive　locks；　but　they　separate　code　that　reads　from　code　　

　　　　　　　　that　writes。　To　improve　code　efficiency；　reader/writer　locks　allow　multiple　readers；　but　　

　　　　　　　　only　a　single　writer。　Reader/writer　locks　are　effective　only　if；　for　the　most　part；　you　are　　

　　　　　　　　reading　data。　



　　　　　o　　Producer/consumer　locks　split　the　task　of　producing　and　consuming　data　into　two　sepa

　　　　　　　　rate　steps。　The　　API　uses　the　producer/consumer　concept　extensively；　examples　are　　

　　　　　　　　Windows。Forms　and　IAsyncResult。　



　　　　　o　　Deadlocks　occur　because　timing　changes　cause　your　code　to　not　be　deterministic。　



　　　　　o　　Deadlocks　can　be　partially　avoided　using　Monitors；　but　the　most　effective　way　of　avoiding　　

　　　　　　　　deadlocks　is　to　use　the　producer/consumer　development　technique。　This　is　because　the　　

　　　　　　　　producer/consumer　architecture　takes　the　approach　of　handing　off　data；　rather　than　　

　　　　　　　　sharing　data。　



　　　　　o　　Applications　that　multitask　effectively　are　applications　that　have　been　designed　using　　

　　　　　　　　logic；　rather　than　development　techniques　where　you　think　up　the　code　as　you　go　along。　



Some　Things　for　You　to　Do　



The　following　is　an　exercise　to　help　you　apply　what　you　learned　in　this　chapter。　



　　　　　1。　　Write　a　general　architecture　that　generates　a　series　using　multiple　threads。　For　the　first　　

　　　　　　　　　series；　generate　the　square　of　all　numbers　between　1　and　100。　For　the　second　series；　　

　　　　　　　　　generate　the　Fibonacci　series。　That　is；　after　two　starting　values；　each　number　is　the　sum　　

　　　　　　　　　of　the　two　preceding　numbers。　The　first　Fibonacci　numbers　are　0；　1；　1；　2；　3；　5；　8；　13；　21；　　

　　　　　　　　　34；　55；　89；　144；　233；　377；　610；　987；　1597；　2584；　4181；　6765；　10946；　17711；　28657；　46368；　　

　　　　　　　　　75025；　121393；　196418；　and　317811。　Outline　the　limits　of　multithreading　when　generating　　

　　　　　　　　　a　series。　


…………………………………………………………Page　392……………………………………………………………


…………………………………………………………Page　393……………………………………………………………

C　　H　　A　　P　　T　　E　　R　　　　　1　　4　



　■　■　■　



Learning　About　Relational　　

　Database　Data　



Literally　hundreds　of　techniques；　tips；　tricks；　and　libraries　are　associated　with　relational　data

bases。　Covering　relational　databases　would　take　an　entire　a　book；　and　in　fact；　many　books　are　　

devoted　to　that　subject。　This　chapter　will　cover　the　basics　and　give　you　enough　knowledge　to　　

read　and　write　to　a　database。　

　　　　　The　focus　of　this　chapter　is　to　demonstrate　accessing　relational　databases　with　ADO　　

and　the　Visual　Studio　Dataset　Designer。　Since　we’ll　need　a　database　to　work　with；　you’ll　also　　

learn　how　to　create　a　database　with　Visual　Basic　Express。　　

　　　　　A　relational　database　stores　data；　such　as　the　lottery　numbers　in　Chapter　10’s　example。　　

Building　on　that　lottery…prediction　example；　in　this　chapter；　you’ll　see　how　to　create　a　database　　

application　that　reads　and　writes　the　lottery　numbers；　and　associates　winners　with　a　particular　　

lottery　drawing。　



Understanding　Relational　Databases　



As　a　beginner　developer；　one　of　your　greatest　challenges　will　be　how　to　manage　relational　database　　

data。　A　relational　database　is　an　old　piece　of　technology。　The　relational　model　on　which　it　is　based　　

was　written　in　about　1969　（according　to　the　relational　model　entry　at　http：//en。wikipedia。org/　

wiki/Relational_model）。　A　relational　database　is　defined　as　follows　（http：//en。wikipedia。org/　

wiki/Relational_database）：　



　　　　　Strictly；　　a　　relational　　database　　is　　merely　　a　　collection　　of　　relations　　（frequently　　called　

　　　　　tables）。　Other　items　are　frequently　considered　part　of　the　database；　as　they　help　to　organize　

　　　　　and　　structure　　the　　data；　　in　　addition　　to　　forcing　　the　　database　　to　　conform　　to　　a　　set　　of　

　　　　　requirements。　



Relational　Database　Tables　



A　relational　database　is　a　collection　of　tables。　When　you　were　reading　and　writing　a　file　in　　

Chapter　10’s　example；　you　were　actually　reading　and　writing　a　table　of　lottery　numbers；　which　　

looked　something　like　this：　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　371　


…………………………………………………………Page　394……………………………………………………………

372　　　　　　　CH　AP　T　E　R　　　1　4　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　R　E　L　A　TI　O　N　AL　　　DA　TA　B　AS　E　　　D　AT　A　



　　　　　　　　　　　2000。05。31　5　6　13　23　25　37　43　

　　　　　　　　　　　2000。06。03　7　10　11　18　32　41　5　

　　　　　　　　　　　2000。06。07　15　23　24　28　38　39　45　

　　　　　　　　　　　2000。06。10　1　3　12　23　29　33　27　

　　　　　　　　　　　2000。06。14　2　4　13　19　39　45　26　

　　　　　　　　　　　2000。06。17　3