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

快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 Enter 键可回到本书目录页 按键盘上方向键 ↑ 可回到本页顶部! 如果本书没有阅读完，想下次继续接着阅读，可使用上方 "收藏到我的浏览器" 功能 和 "加入书签" 功能！


　　　　　　　　key/value　pairs　in　the　　section。　


…………………………………………………………Page　362……………………………………………………………

340　　　　　　　CH　AP　T　E　R　　　1　2　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　A　PP　L　I　CA　TI　O　N　　　CO　N　F　I　G　U　R　AT　IO　N　　　AN　D　　　D　Y　N　A　M　I　C　　L　O　AD　I　N　G　



　　　　　　　　　　　　　　　o　　You　can　enhance　the　　application　configuration　file；　but　that　implies　implementing　　

　　　　　　　　　　　　　　　　　　types　that　specifically　outline　which　XML　nodes　and　attributes　are　to　be　present　in　the　XML。　



　　　　　　　　　　　　　　　o　　When　processing　data；　you　sometimes　need　a　type　（such　as　ConfigurationInfo）　that　is　　

　　　　　　　　　　　　　　　　　　used　to　store　information　in　a　structured　manner　for　a　specific　reason。　　



　　　　　　　　　　　　　　　o　　　has　plenty　of　functionality　that　allows　a　developer　to　dynamically　execute　code。　



　　　　　　　　　　　　　　　o　　One　way　of　dynamically　executing　code　is　to　load　an　assembly；　instantiate　a　type；　and　　

　　　　　　　　　　　　　　　　　　then　cast　the　instance　to　a　specific　known　type。　



　　　　　　　　　　　　　　　o　　You　can　instantiate　private　types　declared　in　an　assembly。　



　　　　　　　　　　　　　　　o　　You　can　use　the　GAC　to　store　assemblies　that　will　be　shared　by　multiple　applications。　



　　　　　　　　　　　　　　　o　　Use　the　GAC　only　if　you　must。　If　you　do　use　the　GAC；　you　need　to　create　strongly　named　　

　　　　　　　　　　　　　　　　　　assemblies　using　signing。　



　　　　　　　　　　　　　　　o　　Regardless　of　how　an　assembly　is　versioned；　a　version　number　should　exist　and　be　used。　



　　　　　　　　　　　　　　　o　　In　convention…based　coding；　your　code　makes　assumptions　about　its　behavior。　　

　　　　　　　　　　　　　　　　　　Convention…based　coding　is　more　pact；　but　because　assumptions　are　made；　the　　

　　　　　　　　　　　　　　　　　　code　is　less　flexible。　However；　do　not　confuse　flexibility　with　being　the　best　way　to　do　　

　　　　　　　　　　　　　　　　　　something。　You　should　have　flexible　code　when　you　need　it；　not　just　because　it　can　be　　

　　　　　　　　　　　　　　　　　　written　that　way。　



　　　　　　　　　　　Some　Things　for　You　to　Do　



　　　　　　　　　　　The　following　are　some　exercises　for　you　to　do　to　apply　what　you’ve　learned　in　this　chapter。　



　　　　　　　　　　　　　　　　1。　　Rewrite　the　configuration　code　so　that　the　configuration　file　specifies　a　directory　where　　

　　　　　　　　　　　　　　　　　　　　all　assemblies　in　that　directory　are　loaded。　　



　　　　　　　　　　　　　　　　2。　　Having　read　all　of　the　assemblies　with　the　rewritten　configuration；　call　a　predefined　　

　　　　　　　　　　　　　　　　　　　　type　that　will　tell　the　caller　which　types　are　available　and　their　appropriate　types。　



　　　　　　　　　　　　　　　　3。　　Modify　ConfigurationLoader　so　that　it　uses　the　new　configuration　architecture　to　　

　　　　　　　　　　　　　　　　　　　　instantiate　types。　


…………………………………………………………Page　363……………………………………………………………

C　　H　　A　　P　　T　　E　　R　　　　　1　　3　



■　■　■　



Learning　About　Multithreading　



Your　brain　allows　you　to　multitask。　For　example；　you　can　prepare　dinner　while　talking　on　the　　

telephone。　However；　this　multitasking　has　limits；　and　you　can　do　only　two　or　three　things　　

simultaneously。　But　suppose　you　could　put　down　the　work；　start　another　piece　of　work；　then　　

put　that　down；　and　then　switch　to　the　original　work。　How　many　tasks　could　you　handle　at　the　　

same　time？　Probably　a　few　hundred；　because　what　you　are　doing　is　serializing　the　multitasking。　　

　　　　　Now　suppose　you　and　another　person　are　preparing　dinner　in　the　kitchen；　but　you　are　not　　

municating　with　each　other。　What　is　the　likelihood　that　you　will　run　into　the　other　person？　　

Probably　pretty　high。　What　I　am　trying　to　get　across　here　is　the　difference　between　multitasking　　

with　a　single　brain　and　multitasking　with　multiple　brains。　Multitasking　always　has　a　cost；　which　is　　

orchestration。　And　sometimes　doing　more　multitasking　is　not　going　to　speed　things　up。　There　　

is　a　limit　to　how　many　brains　are　required　to　run　an　efficient　kitchen。　

　　　　　The　focus　of　this　chapter　is　how　to　write　code　that　is　capable　of　multitasking。　The　operating　　

system　multitasks；　by　default；　but　whether　or　not　your　program　multitasks　depends　on　how　　

you　write　your　code。　For　example；　suppose　the　lighting　controller　introduced　in　Chapter　8　had　　

to　control　3；000　rooms？　To　be　able　to　process　such　a　large　number　of　rooms；　you　would　use　the　　

same　code；　except　run　it　in　parallel。　And　therein　lies　the　problem　of　code　that　needs　to　multitask。　　

It’s　more　difficult　to　make　code　run　efficiently　in　parallel。　A　mon　problem　in　multitasking　　

applications　is　the　dreaded　deadlock。　A　deadlock　occurs　when　two　tasks　need　data　from　each　　

other　to　continue；　which　means　neither　can　continue。　

　　　　　Running　code　in　parallel　requires　coding　discipline；　as　you　will　learn　in　this　chapter。　We　　

will　use　only　a　single　project；　named　JugglingTasks；　which　is　a　console　application　that　imple

ments　the　techniques　demonstrated　in　this　chapter。　



Understanding　Multitasking　



One　of　the　biggest　jumps　in　puting　history　was　when　the　puter　went　from　a　machine　　

that　carried　out　a　single　task　to　a　multitasking　machine。　The　old　modore　64　and　VIC…20　　

were　single…tasking　machines。　You　started　the　puter；　and　then　the　puter　waited　for　　

you　to　do　something。　If　you　decided　to　make　the　puter　run　a　loop　saying　“hello”　millions　　

of　times；　that　is　all　the　puter　would　do。　The　puter　could　not　do　one　thing　and　then　do　　

something　else　while　waiting　for　an　answer　from　the　executing　task。　How　could　anyone　get　　

anything　done？　（On　the　other　hand；　you　could　argue　that　people　might　be　more　productive　if　　

they　could　work　in　only　a　single　program；　and　not　also　check　their　e…mail；　look　at　the　latest　blog　　

entry　from　their　favorite　author；　and　so　on。）　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　341　


…………………………………………………………Page　364……………………………………………………………

342　　　　　　　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　



　　　　　　　　　　　　　　　　Things　changed　quite　dramatically　when　puters　could　multitask。　Server　puters　　

　　　　　　　　　　　running　operating　systems　like　Unix　were　multitasking　from　day　one。　Operating　systems　like　　

　　　　　　　　　　Windows　were　not　100％　preemptive　multitasking　until　Windows　NT　and　Windows　95。　Notice　　

　　　　　　　　　　　that　I　used　the　term　preemptive；　which　makes　a　big　difference。　　

　　　　　　　　　　　　　　　　Plain…vanilla　multitasking　is　multitasking　where　individual　tasks　cooperate　and　allocate　　

　　　　　　　　　　　resources　as　a　collective。　It　is　essentially　a　dead…end　idea；　and　the　best　example　of　how　it　worked　is　　

　　　　　　　　　　Windows　3。0　and　Windows　3。1　（but　these　were　full　of　hacks）。　Now　let’s　see　what　preemptive　　

　　　　　　　　　　　multitasking　means。　



　　　　　　　　　　　Preemptive　Multitasking　



　　　　　　　　　　　Preemptive　multitasking　is　when　the　operating　system　controls　which　application　does　what　　

　　　　　　　　　　　and　when。　Realize　that　you　can　run　an　application　because　applications　are　treated　as　po

　　　　　　　　　　　nents。　You　don’t　believe　me？　Create　a　console　application　and　rename　the　method　Main（）　to　　

　　　　　　　　　　　Mains（）。　See　what　happens。　The　reality　is　that　the　Main（）　method；　as　it　is　declared；　is　an　API　　

　　　　　　　　　　　used　by　the　operating　system　to　run　your　ponent；　which　masquerades　as　a　program。　

　　　　　　　　　　　　　　　　So　we　have　this　program　called　the　operating　system　that　runs　ponents　called　programs。　　

　　　　　　　　　　　The　next　question　is　how　can　multiple　programs　run　at　the　same　time？　The　answer　is　that　the　　

　　　　　　　　　　　operating　system　program　is　no　ordinary　program。　It　is　the　foundation　upon　which　applica

　　　　　　　　　　　tions　can　be　launched　and　managed。　The　operating　system　hooks　into　special　features　of　the　　

　　　　　　　　　　　microprocessor　that　allow　the　operating　system　to　time　slice　the　individual　programs。　Because　　

　　　　　　　　　　your　　programs　are　ponents；　they　will　never　need　to　access　the　microprocessor　directly。　　



　　　　　　　　　　　Time　Slicing　



　　　　　　　　　　　Time　slicing　is　when　an　operating　system　can　dictate　for　how　much　time　a　program　is　allowed　　

　　　　　　　　　　　to　execute。　Between　the　times　of　execution；　the　program　is　in　a　state　of　deep　freeze　and　does　　

　　　　　　　　　　　nothing。　You；　as　a　user；　are　not　aware　of　the　time　slices；　because　a　time　slice　operates　on　the　　

　　　　　　　　　　　order　of　microseconds。　Because　time　slicing　is　so　fast；　you　think　your　program　is　running　　

　　　　　　　　　　　continuously。　To　see　the　time　slicing　in　action；　open　the　Windows　Task　Manager　and　select　the　　

　　　　　　　　　　　Processes　tab。　

　　　　　　　　　　　　　　　　Look　closely　at　the　Task　Manager　window　shown　in　Figure　13…1；　and　you’ll　see　that　　

　　　　　　　　　　　explorer。exe　has　6％　of　the　CPU。　You　can　say　that　the　explorer。exe　application　is　using　the　　

　　　　　　　　　　　appropriate　amount　of　time　slices　that　equals　6％　of　the　CPU　time。　How　the　CPU　slices　the　6％　　

　　　　　　　　　　　is　a　detail　of　the　operating　system。　　

　　　　　　　　　　　　　　　　Say　you　have　a　program　that　runs　two　tasks：　task　1　and　task　2。　The　microprocessor　is　a　single　　

　　　　　　　　　　　core；　and　thus　when　running　two　separate　tasks；　there　will　be　two　time　slices；　as　illustrated　in　　

　　　　　　　　　　　Figure　13…2。　In　the　figure；　the　entire　processing　cycle　is　represented　as　a　pie；　and　each　time　slice　　

　　　　　　　　　　　is　a　slice　of　the　pie。　


…………………………………………………………Page　365……………………………………………………………

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　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　　　　343　



Figure　13…1。　Windows　time　slicing　in　action　



Figure　13…2。　Single…core　microprocessor　running　two　tasks　


…………………………………………………………Page　366……………………………………………………………

344　　　　　　　　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　



　　　　　　　　　　　　　　　　　Notice　how　task　1　and　task　2　run　in　a　serial　manner；　rather　than　concurrently。　This　is　　

　　　　　　　　　　　because　the　microprocessor　is　a　single…task　device　made　to　look　like　a　multitask　device。　You　　

　　　　　　　　　　　would　run　multiple　tasks　on　a　single…core　microprocessor　when　you　want　to　have　application　　

　　　　　　　　　　　background　tasks　that　should　not　affect　the　foreground　task　of　the　application。　For　example；　　

　　　　　　　　　　　when　running　a　word　processor；　you　don’t　want　the　spell　checker　slowing　down　your　typing。　　

　　　　　　　　　　　The　operating　system　will　still　allocate　time　slices　in　this　case　and　use　preemptive　multitasking。　

　　　　　　　　　　　　　　　　　Figure　13…3　illustrates　how　the　same　application　executes　on　a　multiple…core　micropro

　　　　　　　　　　　cessor。　Did　you　notice　what　happened？　The　operating　system；　in　a　bid　to　make　more　efficient　　

　　　　　　　　　　　use　of　the　microprocessor；　has　put　one　task　on　one　core　and　another　task　on　the　other　core。　　

　　　　　　　　　　　Now　both　tasks　are　running　in　parallel。　And　now　it’s　possible　that　both　tasks　would　want　to　　

　　　　　　　　　　　manipulate　the　same　piece　of　data　at　the　same　time。　In　a　single…core　microprocessor；　that　is　　

　　　　　　　　　　　not　physically　possible。　However；　with　a　single　processor；　it　is　still　possible　for　one　task　to　be　　

　　　　　　　　　　　interrupted　mid…flight　while　accessing　some　data；　and　for　the　other　task　to　step　in　and　use　　

　　　　　　　　　　　inconsistent　data。　



　　　　　　　　　　　Figure　13…3。　Multiple…core　microprocessor　running　two　tasks　



　　　　　　　　　　　　　　　　　If　you　hav