C#-マルチコアプログラミングへの手引き-

C#
ϚϧνίΞϓϩάϥϛϯάͷखҾ͖

View Slide

֓ཁ

View Slide

ϚϧνίΞͱ͸
ίΞ͸CPUͷத֩෦෼
ίΞ͕2ͭͷCPU͸2ίΞCPU
2ίΞCPU͸෺ཧίΞ਺2
1ίΞΛෳ਺ίΞ(࿦ཧίΞ਺ͰΧ΢ϯτ)ͷΑ͏ʹѻ͏ϋΠ
ύʔεϨοσΟϯά͕͋Δ
࿦ཧίΞ਺2ͷ෺ཧίΞΛ2ݸ౥ࡌͨ͠CPU͸࿦ཧίΞ਺4

View Slide

ಉظ/ඇಉظͱ͸
ෳ਺ͷॲཧΛಉ࣌ʹ࣮ߦ͢Δ͜ͱ
ಉظͷ৔߹ɺෳ਺ͷॲཧ͕ڞ௨ͷλ
Πϛϯά৴߸ͳͲʹґଘ͢Δ
ඇಉظͷ৔߹͸ڞ௨ͷλΠϛϯά৴
߸౳ʹґଘ͠ͳ͍

View Slide

ϓϩηε
ϓϩάϥϜΛ࣮ߦ͍ͯ͠Δঢ়ଶ
ΞϓϦέʔγϣϯ1ݸىಈͯ͠Ε͹1ݸͷϓϩηε͕ಈ
͍ͯΔ
ෳ਺ͷϓϩηεΛ࣮ߦ͍ͯ͠Δঢ়ଶ͕Ϛϧνϓϩηε
ϚϧνϓϩηεͰͷ݁Ռͷ΍ΓऔΓ͸ग़དྷͳ͍͜ͱ͸
ແ͍͕ҰൠతͰ͸ͳ͍

View Slide

εϨου
ϓϩάϥϜΛ࣮ߦ͍ͯ͠Δͱ͖ͷ࠷খ࣮ߦ୯Ґ
1ͭͷϓϩηε಺ʹ୯ମ·ͨ͸ෳ਺ଘࡏ͢Δ
εϨου͕1ͭͳΒγϯάϧεϨου
ෳ਺ͳΒϚϧνεϨου
ϚϧνεϨουͳΒಉ࣌ʹॲཧΛ࣮ߦͰ͖Δ

View Slide

εϨουͷར఺
ىಈʹ͔͔ΔΦʔόʔϔου͕খ͍͞
εϨουؒͷ௨৴͕ϓϩηεؒ௨৴ʹൺ΂Ε͹ൺֱత
༰қʹߦ͑Δ
OS͕؅ཧ͍ͯ͠Δ
࣮ߦ࣌ʹ͸ϥϯλΠϜ͕ෳ਺ͷεϨουΛੜ੒͍ͯ͠Δ
εϨουϓʔϧͷར༻

View Slide

εϨουϓʔϧ
Ұ౓ੜ੒ͨ͠εϨουΛཷΊ͓ͯ͘ͱ͜Ζ
εϨου༻ͷΩϡʔʹॲཧΛ౤͛Δͱ͍͋
ͯΔεϨου্͕ख͍۩߹ʹॲཧΛ࣮ߦ͠
͍ͯͬͯ͘ΕΔ
εϨουΛ৽ͨʹੜ੒͠ͳ͍͍ͯͨ͘ΊΦʔ
όʔϔου͕ແ͍

View Slide

εϨουͷ۠ผ
جຊతʹεϨουʹछྨ͸ແ͍͕໨తʹΑͬ
໊ͯલ͕͍͍ͭͯΔ
ΞϓϦέʔγϣϯͰUIΛ੍ޚ͢ΔεϨουΛ
UIεϨουͱ͍͏(UIͷมߋ͕Մೳ)
UIεϨου͔Βىಈͨ͠εϨουΛϫʔΧʔε
Ϩουͱ͍͏(UIͷมߋ͕ग़དྷͳ͍)

View Slide

ϑΥΞάϥ΢ϯυεϨου
.NETͷϓϩάϥϜͰ௚઀ThreadΫϥεΛੜ
੒͢ΔͱɺϑΥΞάϥ΢ϯυεϨουͱͳΔ
ෳ਺ͷϑΥΞάϥ΢ϯυεϨου͕͋ͬͨ৔
߹ɺશͯͷϑΥΞάϥ΢ϯυεϨουॲཧ͕
׬ྃ͢Δ·ͰΞϓϦέʔγϣϯ͸ऴྃ͠ͳ͍

View Slide

όοΫάϥ΢ϯυεϨου
ThreadΫϥεΛੜ੒͠ɺIsBackgroundϓϩύςΟΛ
falseʹ͢Δ(͋Δ͍͸ผͷํ๏ͰεϨουΛੜ੒͢Δ)
ͱϑΥΞάϥ΢ϯυεϨουͱͳΔ(نఆ஋͕false)
ϑΥΞάϥ΢ϯυεϨου͕શͯऴྃͨ࣌͠఺Ͱɺ
όοΫάϥ΢ϯυεϨουͷॲཧ͕࢒͍ͬͯͯ΋Ξ
ϓϦέʔγϣϯ͸ڧ੍ऴྃ͢Δ
εϨουϓʔϧ͸όοΫάϥ΢ϯυεϨου

View Slide

λεΫ
εϨουʹ͔ΘΔ৽͍֓͠೦
ศརͰ൚༻ੑ͕ߴ͍
هड़͕؆ܿͰΘ͔Γ΍͍͢
࢖͑ΔͳΒ͹ͳΔ΂͘λεΫΛ༻͍Δ

View Slide

εϨουͷॲཧ׬ྃΛ஌Δʹ͸

View Slide

ϙʔϦϯά
εϨουॲཧΛߦ͏ϝιουΛ࣋ͭΫ
ϥεʹɺॲཧ͕׬͍ྃͯ͠Δ͔Λද͢
ϑϥάΛ࣋ͨͤɺ؅ཧ͓ͤͯ͘͞
ॲཧ͕׬͍ྃͯ͠Δ͔Ͳ͏͔͸ɺஞ࣍
ϑϥάΛ֬ೝ͢Ε͹Α͍

View Slide

Πϕϯτ௨஌
ओʹεϨουͰͷॲཧͷޙʹಛఆͷॲཧΛ࣮ߦ
͍ͨ࣌͠(tryʹର͢ΔﬁnallyͷΑ͏ͳ΋ͷ)ʹ࢖͏
ॲཧ׬ྃޙʹΠϕϯτΛݺͼग़͢ߏ଄ʹ͓ͯ͠
͘
֎͔ΒΠϕϯτΛ௥Ճ͢Δ͜ͱͰॲཧ׬ྃ࣌ʹ
ࣗಈతʹͦͷΠϕϯτΛ࣮ߦͯ͘͠ΕΔ

View Slide

Wait
࣮ߦ͍ͯ͠Δॲཧ͕ऴͬͯ͘ΕΔ·Ͱɺ
ϝΠϯͷεϨουͰ͸εϨουຖʹ༻ҙ
͞Ε͍ͯΔWaitΛ࣮ߦ͢Δ
͜͏͢Δ͜ͱͰɺWaitͰࢦఆͨ͠εϨο
υ͕ऴྃ͢Δ·Ͱ͸ॲཧΛࢭΊ͓ͯ͘ࣄ
͕ग़དྷΔ

View Slide

FCLͷ༷ʑͳεϨουॲཧ

View Slide

1. ࢖͏ͷ͸UIεϨουʁϫʔΧʔεϨουʁ
2. εϨουͷ݁Ռ͸Ͳ͏΍ͬͯड͚औΔʁ
3. εϨουॲཧޙʹίʔϧόοΫϝιου(try
ʹର͢ΔﬁnallyΈ͍ͨͳ΋ͷ)Λ࣮ߦͰ͖
Δʁ
4. ίʔϧόοΫϝιουͰεϨουॲཧޙͷ
݁ՌΛड͚औΕΔʁ
Question

View Slide

ThreadΫϥεͷجຊ
͜ͷํ๏͚͕ͩεϨουϓʔϧΛ࢖Θͳ͍
Thread t = new Thread(new ThreadStart(ॲཧ));ͱ͍͏ײ͡ͰεϨουΛ࡞Δ
t.Start();ͰεϨου։࢝
t.Join();ͰεϨουͷ׬ྃ·ͰݱࡏͷεϨουΛࢭΊΔ
t.Abort();ͰॲཧΛଧͪ੾Δ(ThreadAbortExceptionΛൃੜͤ͞Δ)
IsBackgroundͰϑΥΞ/όοΫάϥ΢ϯυΛมߋՄೳ
IsBackgroundͷنఆ஋͸falseͰϑΥΞάϥ΢ϯυεϨου

View Slide

Answer -Thread-
1. UIεϨουͰ΋ϫʔΧʔεϨουͰ΋ࢦఆՄೳ
2. ड͚औΔखஈ͸ඪ४Ͱ༻ҙ͞Ε͍ͯͳ͍ɻThreadΛར༻͢Δ
ΫϥεͷϑΟʔϧυͳͲΛར༻ͯ͠ڞ༗͢ΔͳͲ͔͠खஈ͸ແ
͍
3. ඪ४Ͱ͸༻ҙ͞Ε͍ͯͳ͍ɻऴྃλΠϛϯάΛϙʔϦϯά/Π
ϕϯτͳͲͰݕग़ͯࣗ͠෼ͰίʔϧόοΫϝιουΛݺͿ
4. ThreadͰ໭Γ஋Λαϙʔτ͍ͯ͠ͳ͍ͷͰແཧɻThreadΛར
༻͢ΔΫϥεͷϑΟʔϧυͳͲΛར༻ͯ͠ڞ༗͢Δ

View Slide

ThreadPoolͷجຊ
bool result = ThreadPool.QueueUserWorkItem(new
WaitCallback(ॲཧ),state);ͰΩϡʔʹॲཧΛૹΕΔ
state͸ObjectܕͳͷͰɺ޷͖ͳҾ਺Λϥοϓͨ͠Ϋϥ
εͳͲΛ౉ͯ͠ॲཧͰΩϟετ͠ɺ࢖ͬͨΓͰ͖Δ
໭Γ஋͸Ωϡʔʹ഑ஔͰ͖ͨΒtrue(͜ͷ໭Γ஋ʹҙຯ
͸͋·Γແ͍ͷͰࣺͯͯ΋OK)
ॲཧ׬ྃΛ଴ͬͨΓڧ੍తʹதஅ͢Δ͜ͱ͸ग़དྷͳ͍

View Slide

Answer -ThreadPool-
1. ৗʹϫʔΧʔεϨου
2. Threadͱಉ༷
3. Threadͱಉ༷
4. Threadͱಉ༷

View Slide

Threadͱͷҧ͍
ৗʹϫʔΧʔεϨου
ThreadͰ͸৽͍͠εϨουΛੜ੒͢Δ͕ɺ
ThreadPoolͰ͸طʹଘࡏ͢ΔεϨουΛ্ख͘ར༻
ͯ͘͠ΕΔͷͰεϨουੜ੒ͷΦʔόʔϔου͕ແ
͍
ϫʔΧʔεϨουͰ͍͍ͷͳΒͪ͜ΒΛੵۃతʹར
༻͢Δͱ͍͍

View Slide

delegateΛ࢖͏
delegateܕ͸ίϯύΠϧ࣌ʹࣗಈͰBeginInvoke/EndInvoke͕࣮૷͞ΕΔ
BeginInvokeΛ࣮ߦ͢ΔͱεϨουϓʔϧͷΩϡʔʹϝιουΛ౉ͤΔ
Ҿ਺ʹ͸ॲཧ࣮ߦޙʹ࣮ߦͯ͠΄͍͠ॲཧ(ίʔϧόοΫϝιου)ͱͦ
ͷॲཧʹඞཁͳҾ਺
ίʔϧόοΫϝιουͰॲཧ݁ՌΛར༻͍ͨ͠৔߹͸EndInvokeϝιο
υΛ࢖͏(ίʔϧόοΫͰ݁ՌΛඞཁͱ͠ͳ͍ͷͳΒEndInvokeϝιου
͸ෆཁͰ͋Δ)
εϨουॲཧͷ׬ྃΛ଴ͭʹ͸໭Γ஋ͷIAsyncResultΛ࢖͑Δ

View Slide

Answer -delegate-
1. ৗʹϫʔΧʔεϨου(BeginInvoke͸εϨουϓʔϧʹ
ॲཧΛ౤͛Δ)
2. BeginInvokeͷ݁ՌIAsyncResultΛ༻͍Δ
3. BeginInvokeͷୈೋୈࡾҾ਺͕̺ʔϧόοΫϝιουؔ܎
4. BeginInvokeͷୈೋҾ਺ʹࢦఆͨ͠ϝιουͰEndInvoke
Λ࣮ߦ͠ɺద੾ͳܕʹΩϟετ͢Δ͜ͱͰ݁ՌΛಘΒΕ
Δ

View Slide

BackgroundWorkerΛ࢖͏
ϑΥʔϜ༻ʹಋೖ͞Εͨ
εϨουͰॲཧ͍ͤͨ͞ίʔυ͸DoWorkΠϕϯτϋϯυ
ϥʔʹ௥Ճ͢Δ
RunWorkerAsyncͰεϨουΩϡʔʹॲཧΛૹΔ
εϨουͷॲཧ͕׬ྃ͢ΔͱRunWorkerCompleteΠϕϯτ͕
ൃੜ͢Δ(͜ͷΠϕϯτ͸UIεϨουͰ࣮ߦ͞ΕΔ)
CancelAsyncͰॲཧதஅΛཁٻͰ͖Δ

View Slide

Answer -BackgroundWorker-
ϫʔΧʔεϨου
ඪ४Ͱ͸උΘ͍ͬͯͳ͍
RunWorkerCompletedΠϕϯτʹొ࿥͢Ε͹Α
͍
ΠϕϯτϋϯυϥʔͷҾ਺Λ্ख͘࢖͑͹͍͚
Δ

View Slide

EAPΛࣗ਎Ͱ࡞Δ
System.ComponentModel໊લۭؒͷ
ComponentΫϥεΛܧঝͯ͠
EAP(Event-based Asynchronous Pattern)
ͷઃܭʹैͬͨಠࣗͷΫϥεΛ࡞ΕΔ
࠶ར༻ͯ͠΋Β͏෦඼ͳͲʹ࢖͏

View Slide

TaskΛ࢖͏
Task t = new Task(ॲཧ);
t.Start();͜ΕͰॲཧΛελʔτग़དྷΔ
Task t = Task.Run(ॲཧ);্2ߦΛ·ͱΊΒΕΔ
Task t = new Task.Factory.StartNew(ॲཧ,Φϓγϣϯ);ͰΦϓγϣϯΛࢦఆͯ͠λεΫ
Λ࡞੒࣮͠ߦͰ͖Δ
t.IsCompletedͰॲཧ͕׬͔ྃͨ͠Ͳ͏͔ௐ΂ΒΕΔ(ϙʔϦϯάͰ࢖͑Δ)
t.Wait();ͰλεΫͷॲཧऴྃΛ଴ػͰ͖Δ
Task.WaitAll(Մม௕ͰλεΫΛࢦఆ);੩తϝιουͰࢦఆͨ͠λεΫશͯͷऴྃΛ଴ػ
Ͱ͖Δ

View Slide

Answer -Task-
1. ϫʔΧʔεϨου
2. ໭Γ஋ͱͯ͠αϙʔτ͍ͯ͠Δ
3. ContinueWithϝιουΛνΣʔϯ͢Δ
͜ͱͰ؆୯ʹՄೳʹͳΔ
4. ؆୯ʹՄೳ

View Slide

εϨου͔Β໭Γ஋ΛಘΔ

View Slide

Thread/ThreadPool
໭Γ஋ͱͯ͠͸αϙʔτ͞Ε͍ͯͳ͍
ϑΟʔϧυͳͲΛڞ༗ͯ͠࢖͏ࣄͰ஋
ͷड͚౉͠Λ࣮ݱ͢Δ͔͠ͳ͍

View Slide

delegate
BeginInvoke/EndInvokeϝιουΛ࢖༻͢Δ͜ͱͰ໭Γ஋Λऔಘ
Ͱ͖Δ
໭Γ஋IAsyncResultܕ͸AsyncResultʹΩϟετͰ͖Δ
AsyncResult.AsyncDelegate͸εϨουϓʔϧʹ౤͛ͨdelegate
ʹΩϟετͰ͖Δ
BeginInvokeϝιουͷ໭Γ஋͔Β͸࠷ऴతͳ݁ՌΛɺ
EndInvokeϝιου͸ίʔϧόοΫϝιου಺Ͱ࢖༻͢Δ͜ͱ
Ͱܧଓॲཧ͢ΔͨΊͷલͷॲཧͷ݁ՌΛಘΔ͜ͱ͕Ͱ͖Δ

View Slide

BackgroundWorker
εϨουͰ࣮ߦ͞ΕΔϝιου͔Β௚઀஋͸ฦͤͳ
͍
DoWorkΠϕϯτϋϯυϥʔͷҾ਺DoWorkEventArgs
ͷResultϓϩύςΟʹฦ͍ͨ͠஋ΛηοτͰ͖Δ
RunWorkerCompletedΠϕϯτϋϯυϥʔͰ
RunWorkerCompletedEventArgsͷResultϓϩύςΟ
Λࢀর͢Δ͜ͱͰ஋ΛऔಘͰ͖Δ

View Slide

Task
໭Γ஋Λαϙʔτ͍ͯ͠Δ
TaskΫϥεͷδΣωϦοΫ൛ʹฦ͍ͨ͠Ҿ਺Λࢦఆͯ͠TaskΛ࡞੒
͠࢖͏
Task t = new Task(ॲཧ);
t.Start();
int result = t.Result;
ResultϓϩύςΟΛ࢖༻ͨ࣌͠఺Ͱɺݺͼग़͠ଆͷεϨου͸݁Ռ
͕ฦͬͯ͘Δ·Ͱ଴ػ͢Δ

View Slide

εϨουͰॲཧ׬ྃޙʹ
ଓ͚ͯผͷॲཧΛͤ͞Δ(ίʔϧόοΫ)

View Slide

Thread/ThreadPool
͜ΕΒͷΫϥεͰ͸εϨουॲཧ׬
ྃޙʹଓ͚ͯผͷॲཧΛ͢Δ࢓૊Έ
͸༻ҙ͞Ε͍ͯͳ͍
εϨουͷ׬ྃΛ଴ͬͯޙଓͷॲཧ
Λ࣮ߦͤ͞Δඞཁ͕͋Δ

View Slide

delegate
delegateͷBeginInvokeϝιουͷҾ਺ʹ͸ίʔϧόοΫ
ϝιου͕౉ͤΔ
εϨουͷॲཧ͕׬ྃ͢ΔͱίʔϧόοΫ͕ݺ͹ΕΔ
͜ͷίʔϧόοΫϝιου͸AsyncCallbackσϦήʔτ
ʹҰக͢ΔγάωνϟΛ࣋ͭඞཁ͕͋Δ
ίʔϧόοΫϝιου͸ϫʔΧʔεϨουͰ࣮ߦ͞ΕΔ
ͷͰUIΛ௚઀ߋ৽Ͱ͖ͳ͍

View Slide

BackgroundWorker
εϨουͰͷॲཧ͕׬ྃ͢ΔͱRunWorkerCompletedΠϕϯτ
͕ݺ͹ΕΔ
͜ͷΠϕϯτϋϯυϥʹॲཧΛࢦఆ͓͚ͯ͠͹ܧଓ࣮ߦ͞ΕΔ
͜ͷΠϕϯτϋϯυϥʔʹ౉͞ΕΔ
RunWorkerCompletedEventArgsͷResultϓϩύςΟ͔Βલͷॲ
ཧͷ݁ՌΛಘΔ͜ͱ͕Ͱ͖Δ
UIεϨουͰ࣮ߦ͞ΕΔ

View Slide

EAP
EAPͰ͸εϨουͷ׬ྃ࣌ʹ
DoWorkCompletedΠϕϯτΛݺͼग़
͢Α͏ʹ࡞Δ
UIεϨουͰ࣮ߦ͞ΕΔ

View Slide

Task(ܧଓλεΫ)
ContinueWithϝιουΛ࢖͏͜ͱͰॲཧΛܧଓ࣮ߦͤ͞Δ͜ͱ͕Ͱ͖
Δ
ResultϓϩύςΟΛ࢖͏͜ͱͰ݁ՌΛಘΔ͜ͱ΋ग़དྷΔ
ResultϓϩύςΟ࢖༻࣌ʹݺͼग़͠ଆͷεϨου͸ॲཧ׬ྃ·Ͱϒ
ϩοΫ͞ΕΔ
Task t =
Task.Run(( ) => ॲཧ).ContinueWith(_t => ॲཧ(_t.Result));
string result = t.Result;

View Slide

Thread

View Slide

using System; 
using System.Threading; 
using System.Threading.Tasks; 
using System.Runtime.Remoting.Messaging; 
 
namespace ConsoleProject 
{ 
class MainClass 
{ 
public static void Main(string[] args) 
{ 
Thread t = new Thread(new ThreadStart(Show)); 
t.Start(); 
Console.WriteLine("Main Method called."); 
t.Join(); 
Console.WriteLine("exit..."); 
} 
 
public static void Show() 
{ 
Thread.Sleep(100); 
Console.WriteLine("Show Method called."); 
} 
} 
} 

View Slide

using System; 
 
{ 
class MainClass 
{ 
static int x = 100; 
 
{ 
//2ͭͷεϨουͰڞ௨ͷϑΟʔϧυ(ࢿݯ)Λར༻͢Δ 
Thread t1 = new Thread(new ThreadStart(ShowAndIncrement)); 
t1.Start(); 
Thread t2 = new Thread(new ThreadStart(Show)); 
t2.Start(); 
 
//ऴྃ଴ͪ 
t1.Join(); 
t2.Join(); 
} 
 
public static void ShowAndIncrement() 
{ 
Console.WriteLine("ShowAndIncrement Method called. ref value = { 0}", x++); 
} 
 
{ 
Console.WriteLine("Show Method called. ref value = { 0}", x); 
} 
} 
}
ShowAndIncrement͸͕࣌ؒ
͔͔ΔॲཧͳͷͰɺ͜ΕͰ͸
ࢥ͏Α͏ͳॱ൪Ͱ࣮ߦ͞Εͳ͍
Thread͸໭Γ஋Λαϙʔτ͍ͯ͠ͳ͍ͷͰ
ϑΟʔϧυΛ࢖ͬͯڞ༗͢Δ
ThreadStart͸Ҿ਺΋
αϙʔτ͞Εͯͳ͍

View Slide

using System; 
 
{ 
class MainClass 
{ 
static int x = 100; 
 
{ 
//2ͭͷεϨουͰڞ௨ͷϑΟʔϧυ(ࢿݯ)Λར༻͢Δ 
Thread t1 = new Thread(new ThreadStart(ShowAndIncrement)); 
t1.Start(); 
t1.Join();//ऴྃΛ଴ͭ 
Thread t2 = new Thread(new ThreadStart(Show)); 
t2.Start(); 
 
//ऴྃ଴ͪ 
t2.Join(); 
} 
 
public static void ShowAndIncrement() 
{ 
Console.WriteLine("ShowAndIncrement Method called. ref value = { 0}", x++); 
} 
 
{ 
Console.WriteLine("Show Method called. ref value = { 0}", x); 
} 
} 
}
͜ΕͳΒ͏·͍͕͘͘
JoinͰॲཧΛ଴ͭ࣌ؒ
͕ඞཁʹͳΔ

View Slide

ThreadPool

View Slide

using System; 
 
{ 
class MainClass 
{ 
//ϙʔϦϯά͢ΔͨΊͷ࢓ֻ͚ 
static bool endFunc = false; 
 
{ 
int x = 100; 
//Ωϡʔʹ഑ஔग़དྷͳ͔ͬͨ৔߹ʹfalse͕ฦͬͯ͘Δ͕΄΅ແҙຯͳͷͰී௨͸औಘ͠ͳͯ͘΋͍͍ 
//ԿނͳΒɺ഑ஔग़དྷͳ͔ͬͨ৔߹͸ྫ֎͕ૹग़͞ΕΔ͔Β 
bool qurResult = ThreadPool.QueueUserWorkItem(new WaitCallback(Show), x); 
//εϨουϓʔϧͷॲཧ͕ऴ͔ྃͨ͠Λ൑ఆ͢Δ࢓ֻ͚͸ඪ४Ͱ͸༻ҙ͞Ε͍ͯͳ͍ 
//ඞཁͳΒϙʔϦϯά͢Δ࢓ֻ͚Λࣗ෼Ͱ༻ҙ͢Δ 
while (!endFunc) 
{ 
//ॲཧ͕ऴΔ·ͰϙʔϦϯά 
} 
} 
 
public static void Show(object x) 
{ 
Console.WriteLine(x); 
Thread.Sleep(2000);//2ඵ͔͔Δॲཧ 
endFunc = true; 
} 
} 
}
ීஈ͸QueueUserWorkItem
ͷ໭Γ஋͸ࣺͯͯΑ͍
ϙʔϦϯάͷखஈ͕༻ҙ
͞Ε͍ͯͳ͍ͨΊࣗ෼Ͱ
࣮૷͢Δඞཁ͕͋Δ
WaitCallbackσϦήʔτͷ
γάωνϟʹैͬͨϝιου

View Slide

delegate

View Slide

using System; 
 
{ 
class MainClass 
{ 
{ 
Action act; 
act = n => Console.WriteLine(n); 
act.BeginInvoke(10, null, null); 
Console.ReadKey(); 
} 
} 
} 

View Slide

using System; 
 
{ 
class TestDelegateAsync 
{ 
 
class MainClass 
{ 
{ 
TestDelegateAsync test = new TestDelegateAsync(); 
TestDelegate d = test.DoWork; 
d.BeginInvoke(test.CallbackMethod, null); 
} 
 
} 
 
public delegate int TestDelegate(); 
 
//࣮ߦ͍ͨ͠ॲཧ 
public int DoWork() 
{ 
Console.WriteLine("DoWork"); 
return 100; 
} 
 
//AsyncCallbackͷγάωνϟʹैͬͨίʔϧόοΫϝιου 
public void CallbackMethod(IAsyncResult ar) 
{ 
//BeginInvokeͷ݁ՌΛ࢖ͬͯɺͦͷεϨου͔Β݁ՌΛநग़ͯ͠දࣔ 
TestDelegate @delegate = (TestDelegate)((AsyncResult)ar).AsyncDelegate; 
int result = @delegate.EndInvoke(ar); 
Console.WriteLine(result); 
} 
} 
} 
࣮ߦ͍ͨ͠ॲཧ͕ೖΔσϦήʔτΛ༻ҙͯ͠
࣮ߦ͍ͨ͠ॲཧΛॻ͘
γάωνϟʹैͬͨίʔϧόοΫϝιου
͜ͷΑ͏ʹͯ݁͠ՌΛಘΒΕΔ

View Slide

Task

View Slide

{ 
class MainClass 
{ 
{ 
Console.WriteLine("Hello World!"); 
var a = new TestAsync(); 
//10͔Β1·Ͱදࣔ͢Δ͕ 
//ঢ়گʹԠͯ͡දࣔॱ͕มΘΔ 
for (int i = 10; i > 0; --i) 
a.Func(i); 
} 
} 
 
class TestAsync 
{ 
public void Func(int x) 
{ 
Task.Run(() => 
{ 
Thread.Sleep(100 * x); 
Console.WriteLine(x++); 
}); 
} 
} 
} 
جຊతͳ࢖͍ํ
Ҿ਺Λදࣔͯ͠Ճࢉ͢Δ
ॏ͍ͨॲཧ

View Slide

͔͠͠ɺ͜ͷํ๏ͩͱϓϩάϥϜ͕࣮ߦͯ͠
εϨουॲཧ͕ऴͬͯͳ͍ঢ়ଶͰ
ΩʔΛೖྗͯ͠΋
ॲཧ్தͰڧ੍ऴྃ͞Εͯ͠·͏
͜ΕΛղܾ͢ΔͨΊʹ
ϝΠϯεϨουͰWait͢ΔͱҎԼͷΑ͏ʹͳΔ

View Slide

{ 
class MainClass 
{ 
{ 
Console.WriteLine("Hello World!"); 
//10͔Β1·Ͱදࣔ͢Δ͕ 
//ঢ়گʹԠͯ͡දࣔॱ͕มΘΔ 
Task[] tasks = new Task[10]; 
for (int i = 10; i > 0; --i) 
tasks[i - 1] = a.Func(i); 
Task.WaitAll(tasks); 
Console.WriteLine("End All Tasks."); 
} 
} 
 
class TestAsync 
{ 
public Task Func(int x) 
{ 
return Task.Run(() => 
{ 
Thread.Sleep(100 * x); 
Console.WriteLine(x++); 
}); 
} 
} 
}
Runͷ໭Γ஋͸TaskܕͰ͋Δ
(͖ͬ͞ͷϓϩάϥϜͰ͸ແࢹࣺͯͯͯͨ͠)
શͯͷλεΫ(໭Γ஋Ͱಘͨ)
͕ऴྃ͢Δ·Ͱ଴ͭ

View Slide

{ 
class MainClass 
{ 
{ 
a.Func(100); 
} 
} 
 
class TestAsync 
{ 
public void Func(int x) 
{ 
var t = Task.Run(() => x)
.ContinueWith(a => Console.WriteLine(a.Result)); 
t.Wait(); 
} 
} 
}
໭Γ஋intͷॲཧΛͯ͠ɺͦͷ໭Γ஋Λ࢖༻ͨ͠
ίʔϧόοΫϝιουݺͼͩ͠ͷྫ
ContinueWithϝιουͷҾ਺ʹೖ͖ͬͯͨ
Runϝιουͷ໭Γ஋(Taskܕ)ͷ
ResultϓϩύςΟΛ࢖͑͹؆୯ʹ
ίʔϧόοΫϝιουʹ஋ΛҾ͖౉ͤΔ

View Slide

async/await

View Slide

໾ׂ
TaskͷܧଓλεΫΛ؆қతʹߦ͏ͨΊͷߏจ
ϝιου୯ҐͰܧଓεϨουΛ؆୯ʹهड़ग़དྷ
ΔΑ͏ʹͳΔ
ܧଓॲཧʹલͷॲཧ݁ՌΛ౉͢͜ͱ΋༰қ
ܧଓॲཧ͚ͩͰͳ͘ɺผͷεϨουͰߦͬͯ΄
͍͠ϝιουͷهड़ͷΑ͏ͳ࢖͍ํ΋ग़དྷΔ

View Slide

async/awaitͷجຊ
await͸म০ͨ͠TaskܕΦϒδΣΫτͷඇಉظॲཧ͕׬ྃͨ͠Βɺͦͷ
݁ՌͷTܕม਺Λฦ͢
awaitͰम০ͨ͠จҎ߱ͷॲཧ͸ͦͷจ͕ऴྃͨ͠Β࣮ߦ͞ΕΔ
awaitͰम০ͨ͠จͷ໭Γ஋Task͸Tܕͷ݁Ռͱͯ͠ม׵͞ΕΔ
async͸ϝιου಺ͰawaitΛ࢖͏͜ͱΛએݴ͢Δ
async͸໭Γ஋ͱͯ͠return͞ΕͨTܕม਺ΛTaskܕʹม׵͢Δ
ϝιουͷ໭Γ஋͸void/Task(͜ͷ2ͭ͸ඇಉظॲཧͰͷ໭Γ஋ແ͠)/
Taskܕͷ͍ͣΕ͔

View Slide

using System; 
 
class async_await 
{ 
static void Main(string[] args) 
{ 
var test = new AsyncTest(); 
test.Test1(); 
} 
} 
 
class AsyncTest 
{ 
//͕͔͔࣌ؒΔͨΊɺผεϨουͰ࣮ߦͯ͠΄͍͠ॲཧ 
//(ผεϨουͰߦͬͯ΋ଞʹѱӨڹΛ༩͑ͳ͍લఏ) 
public async void Test1() 
{ 
await Task.Run(() => 
{ 
Console.WriteLine("Test1ॲཧA"); 
}); 
} 
}
͜ͷ··ͩͱॲཧऴྃલʹ
Կ͔ΩʔΛԡ͢ͱڧ੍ऴྃ

View Slide

using System; 
 
{ 
{ 
test.Test1(); 
} 
} 
 
class AsyncTest 
{ 
//εϨουΛੜ੒͠ɺܧଓλεΫΛߦΘͤΔ 
//ॲཧB΋ॲཧAͱಉ͡εϨουͰߦΘΕ͍ͯΔ͜ͱʹ஫ҙ 
public async void Test1() 
{ 
await Task.Run(() => 
{ 
//࣌ؒͷ͔͔ΔॲཧΛͯ͠΋awaitʹΑͬͯॲཧB͸࣮ߦ͞Εͳ͍ 
Console.WriteLine("Test1ॲཧA"); 
}); 
Console.WriteLine("Test1ॲཧB");//ܧଓॲཧ 
} 
}

View Slide

using System; 
 
 
{ 
{ 
//√3Λදࣔ͢Δɻ 
//ResultϓϩύςΟʹΑΓॲཧऴྃ࣌·ͰϝΠϯεϨου΋ऴྃ͠ͳ͍ 
Console.WriteLine(test.SumTwoAndSqrt(1.0, 2.0).Result); 
} 
} 
 
class AsyncTest 
{ 
//2ͭͷҾ਺Λ଍ͯ͠ฏํࠜΛऔΔϝιουɻ 
//Sqrt͕return͢Δͷ͸doubleܕ͔ͩɺasyncम০ʹΑΓTaskܕʹม׵͞ΕΔ 
public async Task SumTwoAndSqrt(double num1, double num2) 
{ 
//ຊདྷͳΒRun͸TaskΛฦ͕͢ 
//awaitम০ʹΑΓ݁Ռͷdoubleܕม਺ͷΈ͕நग़͞Εͨ 
double result = await Task.Run(() => num1 + num2); 
return Math.Sqrt(result);//લͷॲཧ݁ՌresultΛ༰қʹ࢖͑Δ 
} 
} 

View Slide

ڞ௨ͷࢿݯΛར༻͢Δ

View Slide

lockεςʔτϝϯτ
MonitorΫϥεͷ؆қߏจ
ϩοΫ͞ΕͨίʔυΛผͷεϨου͕࢖͓͏ͱ͢ΔͱɺΦϒδΣ
Ϋτ͕ղ์͞ΕΔ·Ͱ଴ػ (ϒϩοΫ) ͢Δ
lock͢Δ΂͖ΦϒδΣΫτΛlock͠ͳ͍Ͱ࢖༻͢ΔϝιουͳͲ
͕ଘࡏͨ͠৔߹ɺlockΛ࢖͏ίʔυࣗ਎΋҆શͱݴ͑ͳ͘ͳΔ
ڞ௨ʹѻ͏lock͕ඞཁͳ΋ͷΛࢀর͢Δ৔߹ɺࢀর͢ΔશͯͷՕ
ॴͰlock͢΂͖Ͱ͋Δ

View Slide

using System; 
 
 
class MainClass 
{ 
{ 
var t1 = Task.Run(() => 
{ 
Console.WriteLine(ReadTargetLocked()); 
}); 
var t2 = Task.Run(() => 
{ 
IncrementLocked(); 
}); 
Task.WaitAll(t1, t2); 
} 
 
static int target = 1110; 
static object lockObj = new object(); 
 
static int ReadTargetLocked() 
{ 
lock (lockObj) 
{ 
return target; 
} 
} 
 
static void IncrementLocked() 
{ 
lock (lockObj) 
{ 
++target; 
} 
} 
}
ΦϒδΣΫτ͕ϩοΫ͞Ε͍ͯΔͷͰ
ଞͷεϨου͕ͦͷΦϒδΣΫτΛ
ࢀর͠Α͏ͱ͢Δͱ
ΦϒδΣΫτ͕ղ์͞ΕΔ·Ͱ଴ػ (ϒϩοΫ)
͞ΕΔ
௨ৗ͸lock༻ʹΦϒδΣΫτ
Λ1ͭ༻ҙ͓ͯ͘͠
ڞ༗͍ͨ͠ΦϒδΣΫτࣗ਎Ͱ΋͍͍͕
ϩοΫม਺Λpublicͱͯ͠ѻ͍͍ͨ৔߹͸
σουϩοΫͷݪҼʹͳΓ͔Ͷͳ͍
ϩοΫ༻ม਺Λ༻ҙ͢Ε͹publicͰ΋ແ໰୊

View Slide

TPL

View Slide

TPLͷجຊ
Task Parallel Library
λεΫΛΑΓ؆୯ʹ࢖༻Ͱ͖Δ৔߹
͕͋Δ

View Slide

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
 
class TPL 
{ 
{ 
var act = new Action[10]; 
for (int i = 0; i < 10; ++i) 
act[i] = new Action(Show); 
//Invoke͸શͯ׬ྃ͢Δ·ͰϝΠϯεϨου͕ऴྃ͠ͳ͍  
Parallel.Invoke(act); 
} 
 
static void Show() 
{ 
Console.WriteLine("Hello."); 
} 
}

View Slide

using System; 
 
class TPL 
{ 
{ 
//For͸શͯ׬ྃ͢Δ·ͰϝΠϯεϨου͕ऴྃ͠ͳ͍ 
Parallel.For(0, 10, n => 
{ 
Console.WriteLine(n); 
}); 
 
} 
}

View Slide

using System; 
 
class TPL 
{ 
{ 
//ForAll͸શ࣮ͯߦ͞ΕΔ·ͰϝΠϯεϨου͕ऴྃ͠ͳ͍ 
Enumerable.Range(0, 10).AsParallel().ForAll(n => 
{ 
Console.WriteLine(n); 
}); 
 
} 
}

View Slide

C#-マルチコアプログラミングへの手引き-

C#-マルチコアプログラミングへの手引き-

Es_Program

More Decks by Es_Program

Other Decks in Technology

Featured

Transcript