Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00428 008392 10465820 na godz. na dobę w sumie
Programowanie równoległe i asynchroniczne w C# 5.0 - książka
Programowanie równoległe i asynchroniczne w C# 5.0 - książka
Autor: , , , , , Liczba stron: 440
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-6698-0 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c# - programowanie
Porównaj ceny (książka, ebook, audiobook).

Programowanie współbieżne - wykorzystaj w pełni moc procesorów!

Programowanie współbieżne jest w dzisiejszych czasach absolutnym standardem, jedyną drogą pozwalającą w pełni wykorzystać moc wielordzeniowych procesorów, umieszczanych we współczesnych komputerach. Jednak nadal niewielu programistów potrafi poprawnie i efektywnie korzystać z tej technologii. Czas to zmienić!

Jeśli chcesz być naprawdę świetnym programistą C#, tworzącym aplikacje na platformę .NET, a do tej pory nie przestudiowałeś jeszcze porządnie kwestii współbieżności, pora to nadrobić. W tej książce znajdziesz informacje o podstawach tej technologii, takich jak wątki, a także o klasycznych pułapkach związanych z programowaniem współbieżnym. Kolejne rozdziały odkryją przed Tobą tajemnice zadań oraz bibliotek TPL. Poznasz również technologie DSS i CCR oraz dowiesz się co nieco na temat asynchroniczności. Potem przyjdzie kolej na omówienie technologii Reactive Extensions oraz biblioteki CUDAfy.NET, pozwalającej efektywnie wykorzystać karty graficzne do obliczeń niezwiązanych z grafiką. Odkryj zalety programowania równoległego!

Zostań mistrzem programowania współbieżnego!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Redaktor prowadzący: Ewelina Burska Projekt okładki: Studio Gravite/Olsztyn Obarek, Pokoński, Pazdrijowski, Zaprucki Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/proch5 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. ISBN: 978-83-246-6698-0 Copyright © Helion 2014 Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis tre(cid:264)ci Wst(cid:246)p .............................................................................................. 9 Przedmowa .................................................................................... 11 Rozdzia(cid:228) 1. Dla niecierpliwych: asynchroniczno(cid:264)(cid:232) i p(cid:246)tla równoleg(cid:228)a .................. 13 Programowanie asynchroniczne. Operator await i modyfikator async (nowo(cid:286)(cid:252) j(cid:266)zyka C# 5.0 i platformy .NET 4.5) ............................................................................ 13 Klasa Parallel z biblioteki TPL (nowo(cid:286)(cid:252) platformy .NET 4.0) ....................................... 19 Równoleg(cid:225)a p(cid:266)tla For ............................................................................................... 20 Przerywanie p(cid:266)tli ...................................................................................................... 22 Rozdzia(cid:228) 2. W(cid:241)tki ............................................................................................ 25 Monte Carlo .................................................................................................................... 25 Obliczenia bez u(cid:298)ycia dodatkowych w(cid:261)tków ................................................................. 26 Przeniesienie oblicze(cid:276) do osobnego w(cid:261)tku ..................................................................... 28 W(cid:261)tki, procesy i domeny aplikacji ................................................................................. 30 Usypianie bie(cid:298)(cid:261)cego w(cid:261)tku ............................................................................................ 31 Przerywanie dzia(cid:225)ania w(cid:261)tku (Abort) ............................................................................. 32 Wstrzymywanie i wznawiane dzia(cid:225)ania w(cid:261)tku ............................................................... 34 W(cid:261)tki dzia(cid:225)aj(cid:261)ce w tle ..................................................................................................... 35 Zmiana priorytetu w(cid:261)tku ................................................................................................ 36 U(cid:298)ycie wielu w(cid:261)tków i problemy z generatorem liczb pseudolosowych ........................ 36 Pami(cid:266)(cid:252) lokalna w(cid:261)tku i bezpiecze(cid:276)stwo w(cid:261)tku .............................................................. 39 Czekanie na uko(cid:276)czenie pracy w(cid:261)tku (Join) ................................................................... 40 Sekcje krytyczne (lock) .................................................................................................. 43 Przesy(cid:225)anie danych do w(cid:261)tku .......................................................................................... 45 Pula w(cid:261)tków ................................................................................................................... 47 Jeszcze raz o sygnalizacji zako(cid:276)czenia pracy w(cid:261)tków .................................................... 50 Operacje atomowe .......................................................................................................... 51 Tworzenie w(cid:261)tków za pomoc(cid:261) System.Threading. Timer i imitacja timera w w(cid:261)tku z wysokim priorytetem ............................................. 54 Zadania ........................................................................................................................... 57 Rozdzia(cid:228) 3. Zmienne w aplikacjach wielow(cid:241)tkowych ......................................... 59 Atrybut ThreadStatic ...................................................................................................... 59 Opó(cid:296)niona inicjacja i zmienne lokalne w(cid:261)tku ................................................................ 60 Volatile ........................................................................................................................... 64 Zadania ........................................................................................................................... 65 Kup książkęPoleć książkę 4 Programowanie równoleg(cid:228)e i asynchroniczne w C# 5.0 Rozdzia(cid:228) 4. Wi(cid:246)cej o synchronizacji w(cid:241)tków. Blokady i sygna(cid:228)y ......................... 67 Problem ucztuj(cid:261)cych filozofów ...................................................................................... 68 Problem czytelników i pisarzy ........................................................................................ 73 Komunikacja mi(cid:266)dzy w(cid:261)tkami. Problem producenta i konsumenta ............................... 78 Sygnalizacja za pomoc(cid:261) metod Monitor.Pulse i Monitor.Wait ....................................... 81 EventWaitHandle i AutoResetEvent .............................................................................. 85 Bariera ............................................................................................................................ 86 Synchronizacja w(cid:261)tków z ró(cid:298)nych procesów. Muteksy i semafory nazwane ................. 88 Kontrola ilo(cid:286)ci instancji aplikacji ............................................................................. 89 Mutex ....................................................................................................................... 89 Semafor .................................................................................................................... 91 Zadania ........................................................................................................................... 93 Rozdzia(cid:228) 5. W(cid:241)tki a interfejs u(cid:276)ytkownika ......................................................... 95 W(cid:261)tki robocze w aplikacjach desktopowych .................................................................. 95 Przygotowanie projektu aplikacji oraz danych wej(cid:286)ciowych ................................... 96 Wykorzystanie w(cid:261)tków w d(cid:225)ugotrwa(cid:225)ych metodach zdarzeniowych ....................... 99 Synchronizacja w(cid:261)tków z interfejsem u(cid:298)ytkownika w aplikacjach Windows Forms ... 104 BackgroundWorker ...................................................................................................... 110 Synchronizacja w(cid:261)tków z komponentami Windows Presentation Foundation ............. 114 Projekt graficznego interfejsu u(cid:298)ytkownika ........................................................... 115 Implementacja metod zdarzeniowych .................................................................... 117 Bezpieczny dost(cid:266)p do kontrolek WPF .................................................................... 125 Kontekst synchronizacji ............................................................................................... 128 Gro(cid:296)ba zag(cid:225)odzenia w(cid:261)tku interfejsu i asynchroniczna zmiana stanu wspó(cid:225)dzielonych zasobów .......................................................................................... 135 Zadania ......................................................................................................................... 136 Rozdzia(cid:228) 6. Zadania ....................................................................................... 137 Tworzenie zadania ........................................................................................................ 137 Praca z zadaniami ......................................................................................................... 138 Dane przekazywane do zada(cid:276) ....................................................................................... 140 Dane zwracane przez zadania ....................................................................................... 141 Przyk(cid:225)ad: test liczby pierwszej ..................................................................................... 141 Synchronizacja zada(cid:276) ................................................................................................... 143 Przyk(cid:225)ad: sztafeta zada(cid:276) ............................................................................................... 144 Przerywanie zada(cid:276) ........................................................................................................ 145 Stan zadania .................................................................................................................. 149 Fabryka zada(cid:276) ............................................................................................................... 152 Planista i zarz(cid:261)dzanie kolejkowaniem zada(cid:276) ................................................................ 155 Ustawienia zada(cid:276) .......................................................................................................... 159 Zadania ......................................................................................................................... 160 Rozdzia(cid:228) 7. Klasa Parallel. Zrównoleglanie p(cid:246)tli .............................................. 161 Równoleg(cid:225)a p(cid:266)tla for .................................................................................................... 162 Równoleg(cid:225)a p(cid:266)tla foreach ............................................................................................. 163 Metoda Invoke .............................................................................................................. 164 Ustawienia p(cid:266)tli równoleg(cid:225)ych. Klasa ParallelOptions ................................................. 166 Przerywanie p(cid:266)tli za pomoc(cid:261) CancelationToken .......................................................... 166 Kontrola wykonywania p(cid:266)tli ......................................................................................... 168 Synchronizacja p(cid:266)tli równoleg(cid:225)ych. Obliczanie (cid:652) metod(cid:261) Monte Carlo ....................... 169 Partycjonowanie danych ............................................................................................... 175 Zadania ......................................................................................................................... 177 Kup książkęPoleć książkę Spis tre(cid:264)ci 5 Rozdzia(cid:228) 8. Synchronizacja zada(cid:254) ................................................................... 179 Blokady (lock) .............................................................................................................. 179 Sygna(cid:225)y (Monitor.Pulse i Monitor.Wait) ...................................................................... 182 Bariera .......................................................................................................................... 184 Rozdzia(cid:228) 9. Dane w programach równoleg(cid:228)ych ................................................. 187 Praca ze zbiorami danych w programowaniu równoleg(cid:225)ym ......................................... 187 Wspó(cid:225)bie(cid:298)ne struktury danych ............................................................................... 187 Kolekcja ConcurrentBag ........................................................................................ 189 Wspó(cid:225)bie(cid:298)ne kolejka i stos ..................................................................................... 189 Praca z BlockingCollection .................................................................................... 190 W(cid:225)asna kolekcja wspó(cid:225)bie(cid:298)na ................................................................................. 193 Agregacja ............................................................................................................... 197 Agregacje dla kolekcji równoleg(cid:225)ych ..................................................................... 199 PLINQ — zrównoleglone zapytania LINQ .................................................................. 203 Przyk(cid:225)ad zapytania PLINQ ..................................................................................... 204 Jak dzia(cid:225)a PLINQ? ................................................................................................. 205 Kiedy PLINQ jest wydajne? ................................................................................... 207 Metody przekszta(cid:225)caj(cid:261)ce dane wynikowe .............................................................. 208 Przerywanie zapyta(cid:276) .............................................................................................. 209 Metoda ForAll ........................................................................................................ 212 Zadania ......................................................................................................................... 213 Rozdzia(cid:228) 10. Synchronizacja kontrolek interfejsu z zadaniami ............................ 215 Zadania w aplikacjach Windows Forms ....................................................................... 215 Zadania w aplikacjach WPF ......................................................................................... 219 Aktualizacja interfejsu z wykorzystaniem operatora await ........................................... 221 Zadania ......................................................................................................................... 223 Rozdzia(cid:228) 11. Analiza aplikacji wielow(cid:241)tkowych. Debugowanie i profilowanie ...... 225 Okno w(cid:261)tków (Threads) ............................................................................................... 226 Okno zada(cid:276) równoleg(cid:225)ych (Parallel Tasks) .................................................................. 228 Okno stosów równoleg(cid:225)ych (Parallel Stacks) ............................................................... 229 Okno równoleg(cid:225)ego (cid:286)ledzenia zmiennych (Parallel Watch) ......................................... 230 Concurrency Visualizer ................................................................................................ 232 Widok Wykorzystanie CPU ................................................................................... 232 Widok W(cid:261)tki .......................................................................................................... 233 Widok Rdzenie ....................................................................................................... 236 Profilowanie aplikacji zewn(cid:266)trznych ...................................................................... 237 Znaczniki ................................................................................................................ 238 Zadania ......................................................................................................................... 241 Rozdzia(cid:228) 12. Wst(cid:246)p do CCR i DSS .................................................................... 243 Instalacja (cid:286)rodowiska Microsoft Robotics .................................................................... 245 Mo(cid:298)liwe problemy z uruchomieniem (cid:286)rodowiska Robotics ................................... 247 Kompilacja i uruchamianie projektów do(cid:225)(cid:261)czonych do ksi(cid:261)(cid:298)ki ............................. 248 CCR i DSS w pigu(cid:225)ce ................................................................................................... 249 Czujniki i urz(cid:261)dzenia — tworzenie pierwszej us(cid:225)ugi ............................................. 249 Serwisy partnerskie ................................................................................................ 265 Rozdzia(cid:228) 13. Skalowalne rozwi(cid:241)zanie dla systemów rozproszonych na bazie technologii CCR i DSS .................................................. 277 Opó(cid:296)nione uruchamianie .............................................................................................. 291 Uruchamianie oblicze(cid:276) na klastrze ............................................................................... 293 Podsumowanie .............................................................................................................. 298 Zadania ......................................................................................................................... 299 Kup książkęPoleć książkę 6 Programowanie równoleg(cid:228)e i asynchroniczne w C# 5.0 Rozdzia(cid:228) 14. Wprowadzenie do Reactive Extensions. Zarz(cid:241)dzanie sekwencjami zdarze(cid:254) .............................................. 301 Programowanie reaktywne ........................................................................................... 302 IObservable T ..................................................................................................... 303 IObserver T ......................................................................................................... 303 Dualizm interaktywno-reaktywny .......................................................................... 304 Obserwator — wzorzec projektowy ....................................................................... 305 Platforma Rx ................................................................................................................. 306 Biblioteki Rx .......................................................................................................... 307 Gramatyka Rx ............................................................................................................... 309 Jak korzysta(cid:252) z interfejsów w Rx? ......................................................................... 309 Subskrypcje ............................................................................................................ 312 LINQ do zdarze(cid:276) .................................................................................................... 315 Zimne i gor(cid:261)ce obserwable ........................................................................................... 329 Rozdzia(cid:228) 15. Wspó(cid:228)bie(cid:276)no(cid:264)(cid:232) w Rx ..................................................................... 333 Zarz(cid:261)dzanie równoleg(cid:225)o(cid:286)ci(cid:261) ......................................................................................... 333 Interfejs IScheduler ................................................................................................ 334 Plani(cid:286)ci ................................................................................................................... 335 Metody SubscribeOn i ObserveOn ......................................................................... 339 S(cid:225)owo o unifikacji .................................................................................................. 343 Rozdzia(cid:228) 16. Przyk(cid:228)ady u(cid:276)ycia technologii Rx w aplikacjach WPF ....................... 345 Rysowanie z u(cid:298)yciem Rx ............................................................................................. 346 Wyszukiwarka .............................................................................................................. 353 Rozdzia(cid:228) 17. CUDA w .NET ............................................................................... 365 Konfiguracja (cid:286)rodowiska dla CUDAfy.NET ................................................................ 366 Pierwsze kroki .............................................................................................................. 368 Hello World, czyli pierwszy program CUDAfy.NET ................................................... 370 Emulator GPU .............................................................................................................. 375 W(cid:225)asno(cid:286)ci GPU ............................................................................................................ 376 Przekazywanie parametrów do kerneli ......................................................................... 378 Operacje na pami(cid:266)ci globalnej karty graficznej ............................................................ 380 Pomiar czasu wykonania .............................................................................................. 383 Dost(cid:266)p zwarty do pami(cid:266)ci globalnej i pami(cid:266)(cid:252) wspó(cid:225)dzielona ...................................... 386 Generator liczb pseudolosowych .................................................................................. 390 FFT na GPU ................................................................................................................. 392 BLAS ............................................................................................................................ 394 Zadania ......................................................................................................................... 395 Dodatek A Biblioteka TPL w WinRT ............................................................... 397 Zadania ......................................................................................................................... 398 Struktura SpinWait ....................................................................................................... 400 Usypianie w(cid:261)tków ........................................................................................................ 400 Pula w(cid:261)tków ................................................................................................................. 401 ThreadPoolTimer .......................................................................................................... 402 Podobie(cid:276)stwa ................................................................................................................ 403 Przeno(cid:286)na biblioteka ..................................................................................................... 404 Zadania ......................................................................................................................... 406 Kup książkęPoleć książkę Spis tre(cid:264)ci 7 Dodatek B Dobre praktyki programowania aplikacji wielow(cid:241)tkowych .............. 407 Wprowadzenie .............................................................................................................. 407 Sekcje krytyczne i zakleszczenia .................................................................................. 407 Wy(cid:286)cig .......................................................................................................................... 411 S(cid:225)owo kluczowe volatile i kontrola p(cid:266)tli wykonywanej w ramach funkcji w(cid:261)tku ........ 417 Bezpiecze(cid:276)stwo w(cid:261)tków a konstruktory i pola statyczne ............................................. 419 Dodatek C Menad(cid:276)er pakietów NuGet .............................................................. 423 Instalacja NuGet ........................................................................................................... 423 Korzystanie z NuGet .................................................................................................... 425 Skorowidz ................................................................................... 427 Kup książkęPoleć książkę 8 Programowanie równoleg(cid:228)e i asynchroniczne w C# 5.0 Kup książkęPoleć książkę Rozdzia(cid:228) 1. Dla niecierpliwych: asynchroniczno(cid:264)(cid:232) i p(cid:246)tla równoleg(cid:228)a Jacek Matulewski Zgodnie z zasad(cid:261) Pareto, w wi(cid:266)kszo(cid:286)ci przypadków czytelnicy b(cid:266)d(cid:261) potrzebowali tylko znikomej cz(cid:266)(cid:286)ci wiedzy przedstawionej w tej ksi(cid:261)(cid:298)ce. Postanowi(cid:225)em wobec tego w roz- dziale 1. opisa(cid:252) dwie nowo(cid:286)ci platformy .NET 4.0 i 4.5, które wydaj(cid:261) mi si(cid:266) najwa(cid:298)- niejsze i które prawdopodobnie b(cid:266)d(cid:261) najcz(cid:266)(cid:286)ciej u(cid:298)ywane w programach czytelników. Programowanie asynchroniczne. Operator await i modyfikator async (nowo(cid:264)(cid:232) j(cid:246)zyka C# 5.0 i platformy .NET 4.5) J(cid:266)zyk C# 5.0 wyposa(cid:298)ony zosta(cid:225) w nowy operator await, u(cid:225)atwiaj(cid:261)cy synchronizacj(cid:266) dodatkowych zada(cid:276) uruchomionych przez u(cid:298)ytkownika. Poni(cid:298)ej zaprezentuj(cid:266) prosty przyk(cid:225)ad jego u(cid:298)ycia, który powinien wyja(cid:286)ni(cid:252) jego dzia(cid:225)anie. Dzia(cid:225)anie tego operatora zwi(cid:261)zane jest (cid:286)ci(cid:286)le z bibliotek(cid:261) TPL (ang. Task Parallel Library) i jej sztandarow(cid:261) klas(cid:261) Task, które zostan(cid:261) omówione w kolejnych rozdzia(cid:225)ach. Jednak podobnie jak w przypad- ku opisanej ni(cid:298)ej p(cid:266)tli równoleg(cid:225)ej Parallel.For, tak i w przypadku operatora await dog(cid:225)(cid:266)bna znajomo(cid:286)(cid:252) biblioteki TPL nie jest konieczna. Kup książkęPoleć książkę 14 Programowanie równoleg(cid:228)e i asynchroniczne w C# 5.0 Spójrzmy na przyk(cid:225)ad widoczny na listingu 1.1, w którym przedstawiam metod(cid:266) zdarze- niow(cid:261) przycisku. Zdefiniowana jest w niej przyk(cid:225)adowa akcja pobieraj(cid:261)ca obiekt typu object, a zwracaj(cid:261)ca liczb(cid:266) ca(cid:225)kowit(cid:261) long. Referencj(cid:266) do niej zapisuj(cid:266) w zmiennej akcja i uruchamiam j(cid:261) (synchronicznie). Czynno(cid:286)(cid:252) owa wprowadza jednosekundowe opó(cid:296)nienie za pomoc(cid:261) metody Thread.Sleep (nale(cid:298)y zadeklarowa(cid:252) u(cid:298)ycie przestrzeni nazw System.Threading1), które — oczywi(cid:286)cie — opó(cid:296)nia wykonywanie ca(cid:225)ej metody zdarzeniowej po klikni(cid:266)ciu przycisku. W efekcie na jedn(cid:261) sekund(cid:266) aplikacja zamiera. Listing 1.1. Synchroniczne wykonywanie kodu zawartego w akcji private void button1_Click(object sender, EventArgs e) { Func object, long akcja = (object argument) = { msgBox( Akcja: Pocz(cid:230)tek, argument: + argument.ToString()); Thread.Sleep(1000); //opó(cid:296)nienie msgBox( Akcja: Koniec ); return DateTime.Now.Ticks; }; msgBox( button1_Click: Pocz(cid:230)tek ); msgBox( Wynik: +akcja( synchronicznie )); msgBox( button1_Click: Koniec ); } void msgBox(string komunikat) { string taskID = Task.CurrentId.HasValue ? Task.CurrentId.ToString() : UI ; MessageBox.Show( ! + komunikat + ( + taskID + ) ); } W metodzie przedstawionej na listingu 1.2 ta sama akcja wykonywana jest asynchro- nicznie w osobnym w(cid:261)tku utworzonym przez platform(cid:266) .NET na potrzeby zdefinio- wanego tu zadania (instancja klasy Task z TPL). Synchronizacja nast(cid:266)puje w momencie odczytania warto(cid:286)ci zadanie.Result, czyli warto(cid:286)ci zwracanej przez czynno(cid:286)(cid:252) akcja. Jej sekcja get czeka ze zwróceniem warto(cid:286)ci a(cid:298) do zako(cid:276)czenia akcji wykonywanej przez zadanie, wstrzymuj(cid:261)c do tego czasu w(cid:261)tek, w którym wykonywana jest metoda button1_Click. Jest to zatem typowy punkt synchronizacji, cho(cid:252) troch(cid:266) ukryty. Warto zwróci(cid:252) uwag(cid:266), (cid:298)e po instrukcji zadanie.Start(), a przed odczytaniem w(cid:225)asno(cid:286)ci zadanie. (cid:180)Result mog(cid:261) by(cid:252) wykonywane dowolne czynno(cid:286)ci, o ile s(cid:261) niezale(cid:298)ne od warto(cid:286)ci zwróconej przez zadanie. Listing 1.2. U(cid:298)ycie zadania do asynchronicznego wykonania kodu private void button1_Click(object sender, EventArgs e) { Func object, long akcja = (object argument) = 1 Alternatywnie mogliby(cid:286)my u(cid:298)y(cid:252) instrukcji await Task.Delay(1000);, ale wówczas musieliby(cid:286)my oznaczy(cid:252) wyra(cid:298)enie lambda jako async, a wtedy nale(cid:298)a(cid:225)oby referencj(cid:266) do niego zapisa(cid:252) w zmiennej typu Func object, Task long . Kup książkęPoleć książkę Rozdzia(cid:228) 1. (cid:105) Dla niecierpliwych: asynchroniczno(cid:264)(cid:232) i p(cid:246)tla równoleg(cid:228)a 15 { msgBox( Akcja: Pocz(cid:230)tek, argument: + argument.ToString()); Thread.Sleep(1000); //opó(cid:296)nienie msgBox( Akcja: Koniec ); return DateTime.Now.Ticks; }; Task long zadanie = new Task long (akcja, zadanie ); zadanie.Start(); msgBox( Akcja zosta(cid:273)a uruchomiona ); if (zadanie.Status != TaskStatus.Running zadanie.Status!=TaskStatus.RanToCompletion) msgBox( Zadanie nie zosta(cid:273)o uruchomione ); else msgBox( Wynik: +zadanie.Result); msgBox( button1_Click: Koniec ); } Nie jest konieczne, aby instrukcja odczytania w(cid:225)asno(cid:286)ci Result znajdowa(cid:225)a si(cid:266) w tej samej metodzie, co uruchomienie zadania — nale(cid:298)y tylko do miejsca jej odczytania przekaza(cid:252) referencj(cid:266) do zadania (w naszym przypadku zmienn(cid:261) typu Task long ). Zwy- kle referencj(cid:266) t(cid:266) przekazuje si(cid:266) jako warto(cid:286)(cid:252) zwracan(cid:261) przez metod(cid:266) uruchamiaj(cid:261)c(cid:261) zadanie. Przyk(cid:225)ad takiej metody widoczny jest na listingu 1.3. Je(cid:298)eli u(cid:298)ywamy angielskich nazw metod, jest zwyczajem, aby metoda tworz(cid:261)ca i uruchamiaj(cid:261)ca zadanie mia(cid:225)y przy- rostek ..Async. Listing 1.3. Wzór metody wykonuj(cid:261)cej jak(cid:261)(cid:286) czynno(cid:286)(cid:252) asynchronicznie Task long DoSomethingAsync(object argument) { Func object, long akcja = (object _argument) = { msgBox( Akcja: Pocz(cid:230)tek, argument: + _argument.ToString()); Thread.Sleep(1000); //opó(cid:296)nienie msgBox( Akcja: Koniec ); return DateTime.Now.Ticks; }; Task long zadanie = new Task long (akcja, argument); zadanie.Start(); return zadanie; } protected void button1_Click(object sender, EventArgs e) { msgBox( button1_Click: Pocz(cid:230)tek ); Task long zadanie = DoSomethingAsync( zadanie-metoda ); msgBox( Akcja zosta(cid:273)a uruchomiona ); if (zadanie.Status != TaskStatus.Running zadanie.Status!=TaskStatus.RanToCompletion) msgBox( Zadanie nie zosta(cid:273)o uruchomione ); else msgBox( Wynik: + zadanie.Result); msgBox( button1_Click: Koniec ); } Kup książkęPoleć książkę 16 Programowanie równoleg(cid:228)e i asynchroniczne w C# 5.0 Po tym wprowadzeniu mo(cid:298)emy przej(cid:286)(cid:252) do omówienia zasadniczego tematu. Wraz z wer- sjami 4.0 i 4.5 w platformie .NET (oraz w platformie Windows Runtime) pojawi(cid:225)o si(cid:266) wiele metod podobnych do przedstawionej powy(cid:298)ej metody DoSomethingAsync (ale — oczywi(cid:286)cie — w odró(cid:298)nieniu od niej robi(cid:261)cych co(cid:286) po(cid:298)ytecznego). Metody te wykonuj(cid:261) asynchronicznie ró(cid:298)nego typu d(cid:225)ugotrwa(cid:225)e czynno(cid:286)ci. Znajdziemy je w klasie HttpClient, w klasach odpowiedzialnych za obs(cid:225)ug(cid:266) plików (StorageFile, StremWriter, Stream (cid:180)Reader, XmlReader), w klasach odpowiedzialnych za kodowanie i dekodowanie ob- razów czy w klasach WCF. Asynchroniczno(cid:286)(cid:252) jest wr(cid:266)cz standardem w aplikacjach Windows 8 z interfejsem Modern UI. I w(cid:225)a(cid:286)nie po to, aby ich u(cid:298)ycie by(cid:225)o (prawie) tak proste jak metod synchronicznych, wprowadzony zosta(cid:225) w C# 5.0 (co odpowiada plat- formie .NET 4.5) operator await. U(cid:225)atwia on synchronizacj(cid:266) dodatkowego zadania two- rzonego przez te metody. Nale(cid:298)y jednak pami(cid:266)ta(cid:252), (cid:298)e metod(cid:266), w której chcemy u(cid:298)y(cid:252) ope- ratora await, musimy oznaczy(cid:252) modyfikatorem async. Prezentuj(cid:266) to na listingu 1.4. Listing 1.4. Przyk(cid:225)ad u(cid:298)ycia modyfikatora async i modyfikatora await protected async void button1_Click(object sender, EventArgs e) { msgBox( button1_Click: Pocz(cid:230)tek ); Task long zadanie = DoSomethingAsync( async/await ); msgBox( Akcja zosta(cid:273)a uruchomiona ); long wynik = await zadanie; msgBox( Wynik: + wynik); msgBox( button1_Click: Koniec ); } Operator await zwraca parametr u(cid:298)yty w klasie parametrycznej Task . Zatem w przy- padku zadania typu Task long b(cid:266)dzie to zmienna typu long. Je(cid:298)eli u(cid:298)yta zosta(cid:225)a wersja nieparametryczna klasy Task, operator zwraca void i s(cid:225)u(cid:298)y jedynie do synchronizacji (nie przekazuje wyniku; nieparametryczna klasa Task nie ma tak(cid:298)e w(cid:225)asno(cid:286)ci Result). Metody oznaczone modyfikatorem async nazywane s(cid:261) w angielskiej dokumentacji MSDN async method. Mo(cid:298)e to jednak wprowadza(cid:252) pewne zamieszanie. Z powodu tej nazwy metody z modyfikatorem async (w naszym przypadku metoda Button1_Click) uto(cid:298)- samiane s(cid:261) z metodami wykonuj(cid:261)cymi asynchronicznie jakie(cid:286) czynno(cid:286)ci (a tak(cid:261) w na- szym przypadku jest DoSomethingAsync). Osobom poznaj(cid:261)cym dopiero temat cz(cid:266)sto wydaje si(cid:266), (cid:298)e aby metoda wykonywana by(cid:225)a asynchronicznie, wystarczy doda(cid:252) do jej sygnatury modyfikator async. To nie jest prawda! Mo(cid:298)emy wywo(cid:225)a(cid:252) metod(cid:266) DoSomethingAsync w taki sposób, (cid:298)e umie(cid:286)cimy j(cid:261) bezpo- (cid:286)rednio za operatorem await, np. long wynik = await DoSomethingAsync( async/ (cid:180)await );. Jaki to ma sens? Wykonywanie metody button1_Click, w której znajduje si(cid:266) to wywo(cid:225)anie, zostanie wstrzymane a(cid:298) do momentu zako(cid:276)czenia metody DoSomething (cid:180)Async, wi(cid:266)c efekt, jaki zobaczymy na ekranie, b(cid:266)dzie identyczny z wynikiem w przy- padku synchronicznym (listing 1.1). Ró(cid:298)nica jest jednak wyra(cid:296)na i to jest zasadnicza nowo(cid:286)(cid:252), bo instrukcja zawieraj(cid:261)ca operator await nie blokuje w(cid:261)tku, w którym wywo(cid:225)ana zosta(cid:225)a metoda button1_Click. Kompilator zawiesza wywo(cid:225)anie metody button1_Click, przechodz(cid:261)c do kolejnych czynno(cid:286)ci w miejscu jej wywo(cid:225)ania a(cid:298) do momentu zako(cid:276)- czenia uruchomionego zadania. W momencie, gdy to nast(cid:261)pi, w(cid:261)tek wraca do metody Kup książkęPoleć książkę Rozdzia(cid:228) 1. (cid:105) Dla niecierpliwych: asynchroniczno(cid:264)(cid:232) i p(cid:246)tla równoleg(cid:228)a 17 button1_Click i kontynuuje jej dzia(cid:225)anie2. Jednak w programie, na którym w tej chwili testujemy operator await, efektów tego nie zobaczymy. Efekt b(cid:266)dzie widoczny dopiero wtedy, gdy metod(cid:266) button1_Click wywo(cid:225)amy z innej metody — niech b(cid:266)dzie to metoda zdarzeniowa button2_Click zwi(cid:261)zana z drugim przyciskiem. Nale(cid:298)y za- uwa(cid:298)y(cid:252), (cid:298)e w serii instrukcji wywo(cid:225)anie metody oznaczonej modyfikatorem async nie musi si(cid:266) zako(cid:276)czy(cid:252) przed wykonaniem nast(cid:266)pnej instrukcji — i w tym sensie jest ona asynchroniczna. Aby tak si(cid:266) sta(cid:225)o, musi w niej jednak zadzia(cid:225)a(cid:252) operator await czekaj(cid:261)cy na wykonanie jakiego(cid:286) zadania (w naszym przyk(cid:225)adzie metody DoSomethingAsync). W efekcie, w scenariuszu przedstawionym na listingu 1.5 metoda button2_Click zako(cid:276)- czy si(cid:266) przed zako(cid:276)czeniem button1_Click. Listing 1.5. Dzia(cid:225)anie modyfikatora async private async void button1_Click(object sender, EventArgs e) { msgBox( button1_Click: Pocz(cid:230)tek ); long wynik = await DoSomethingAsync( async/await ); msgBox( Wynik: + wynik.ToString()); msgBox( button1_Click: Koniec ); } private void button2_Click(object sender, EventArgs e) { msgBox( button2_Click: Pocz(cid:230)tek ); button1_Click(null, null); msgBox( button2_Click: Koniec ); } Wa(cid:298)na rzecz: samo u(cid:298)ycie operatora await i modyfikatora async nie powoduje utwo- rzenia nowych zada(cid:276) lub w(cid:261)tków! Powoduje jedynie przekazanie na pewien czas ste- rowania z metody, w której znajduje si(cid:266) operator await i oznaczonej modyfikatorem async, do metody, która j(cid:261) wywo(cid:225)a(cid:225)a, i powrót w momencie uko(cid:276)czenia zadania, na jakie czeka await. Koszt jest zatem niewielki i rozwi(cid:261)zanie to mo(cid:298)e by(cid:252) z powodzeniem stosowane bez obawy o utrat(cid:266) wydajno(cid:286)ci. Ponadto, w(cid:225)a(cid:286)nie z uwagi na wydajno(cid:286)(cid:252), operator await sprawdza, czy w momencie, w którym dociera do niego sterowanie, metoda asynchroniczna nie jest ju(cid:298) zako(cid:276)czona. Je(cid:298)eli tak, praca kontynuowana jest syn- chronicznie bez zb(cid:266)dnych skoków. Metoda z modyfikatorem async mo(cid:298)e zwraca(cid:252) warto(cid:286)(cid:252) void — tak jak w przedsta- wionej wy(cid:298)ej metodzie zdarzeniowej button1_Click. Jednak w takim przypadku jej dzia(cid:225)anie nie mo(cid:298)e by(cid:252) (cid:298)aden sposób synchronizowane. Po uruchomieniu nie mamy nad ni(cid:261) (cid:298)adnej kontroli. Szczególnie nie mo(cid:298)na u(cid:298)y(cid:252) operatora await ani metody Wait klasy Task, aby poczeka(cid:252) na jej zako(cid:276)czenie. (cid:297)eby to by(cid:225)o mo(cid:298)liwe, metoda z mody- fikatorem async musi zwraca(cid:252) referencj(cid:266) Task lub Task . Wówczas mo(cid:298)liwe jest u(cid:298)ycie operatora await, za którym mo(cid:298)na zreszt(cid:261) ustawi(cid:252) dowolne wyra(cid:298)enie o warto(cid:286)ci Task 2 Aby taki efekt uzyska(cid:252) bez operatora await, nale(cid:298)a(cid:225)oby u(cid:298)y(cid:252) konstrukcji opartej na funkcjach zwrotnych (ang. callback). W efekcie kod sta(cid:225)by si(cid:266) raczej skomplikowany i przez to podatny na b(cid:225)(cid:266)dy. Warto te(cid:298) zauwa(cid:298)y(cid:252), (cid:298)e await nie jest prostym odpowiednikiem metody Task.Wait, która po prostu zatrzyma(cid:225)aby bie(cid:298)(cid:261)cy w(cid:261)tek do momentu zako(cid:276)czenia zadania. W przypadku operatora await nast(cid:261)pi przekazanie sterowania do metody wywo(cid:225)uj(cid:261)cej i powrót w momencie zako(cid:276)czenia zadania. Kup książkęPoleć książkę 18 Programowanie równoleg(cid:228)e i asynchroniczne w C# 5.0 lub Task (zmienne i w(cid:225)asno(cid:286)ci tego typu oraz metody lub wyra(cid:298)enia lambda zwra- caj(cid:261)ce warto(cid:286)(cid:252) tego typu3). Przekazane zadanie umo(cid:298)liwia synchronizacj(cid:266). Ponadto u(cid:298)ycie wersji parametrycznej pozwala na zwrócenie warto(cid:286)ci przekazywanej potem przez operator await. Sprawd(cid:296)my to, tworz(cid:261)c odpowiednik metody button1_Click ze zmienion(cid:261) sygnatur(cid:261) (nie mo(cid:298)emy tego zrobi(cid:252) z orygina(cid:225)em, bo jest zwi(cid:261)zany ze zdarzeniem button1.Click). Nowa metoda o nazwie DoSomethingMoreAsync widoczna jest na listingu 1.64. Usun(cid:261)(cid:225)em argumenty, których i tak nie u(cid:298)ywali(cid:286)my, i zmieni(cid:225)em zwracan(cid:261) warto(cid:286)(cid:252) z void na Task. Dzi(cid:266)ki temu metoda ta nie jest ju(cid:298) typu „wystrzel i zapomnij”, a mo(cid:298)e by(cid:252) kon- trolowana z miejsca uruchomienia (zob. widoczna równie(cid:298) na listingu 1.6 metoda button2_Click). Zdziwienie mo(cid:298)e budzi(cid:252) jednak fakt, (cid:298)e za s(cid:225)owem kluczowym return w metodzie DoSomethingMoreAsync wcale nie ma instrukcji tworz(cid:261)cej zwracane przez t(cid:261) metod(cid:266) zadanie (instrukcji return mog(cid:225)oby wcale nie by(cid:252)). W metodach z modyfi- katorem async i zwracaj(cid:261)cych warto(cid:286)(cid:252) Task zadanie jest przypisywane przez kompi- lator. W ten sposób u(cid:225)atwiona jest wielostopniowa obs(cid:225)uga metod asynchronicznych. Nale(cid:298)y jednak pami(cid:266)ta(cid:252), (cid:298)e te metody nie tworz(cid:261) nowych zada(cid:276), a jedynie je przekazuj(cid:261). Listing 1.6. Metoda async zwracaj(cid:261)ca zadanie private async Task DoSomethingMoreAsync() { msgBox( DoSomethingMoreAsync: Pocz(cid:230)tek ); long wynik = await DoSomethingAsync( async/await ); msgBox( DoSomethingMoreAsync: Wynik: + wynik.ToString()); msgBox( DoSomethingMoreAsync: Koniec ); return; } private async void button2_Click(object sender, EventArgs e) { msgBox( button2_Click: Pocz(cid:230)tek ); await DoSomethingMoreAsync(); msgBox( button2_Click: Koniec ); } A co w przypadku metod async, które mia(cid:225)yby zwraca(cid:252) warto(cid:286)(cid:252)? Za(cid:225)ó(cid:298)my, (cid:298)e metoda DoSomethingMore mia(cid:225)aby zwraca(cid:252) warto(cid:286)(cid:252) typu long (np. warto(cid:286)(cid:252) zmiennej wynik). Wtedy nale(cid:298)y zmieni(cid:252) typ tej metody na Task long , a za s(cid:225)owem kluczowym return wstawi(cid:252) warto(cid:286)(cid:252) typu long. Pokazuj(cid:266) to na listingu 1.7. Warto zapami(cid:266)ta(cid:252), cho(cid:252) to uproszczone stwierdzenie, (cid:298)e w metodach async operator await wy(cid:225)uskuje z typu Task parametr, a s(cid:225)owo kluczowe return w metodach async zwracaj(cid:261)ce warto(cid:286)(cid:252) typu Task dzia(cid:225)a odwrotnie — otacza dowolne obiekty typem Task . 3 Prawd(cid:266) mówi(cid:261)c, nale(cid:298)a(cid:225)oby to stwierdzenie u(cid:286)ci(cid:286)li(cid:252), bo nie tylko zadania mog(cid:261) by(cid:252) argumentem operatora await, a ka(cid:298)dy typ, który zwraca metod(cid:266) GetAwaiter. Wi(cid:266)cej informacji dost(cid:266)pnych jest na stronie FAQ zespo(cid:225)u odpowiedzialnego za implementacj(cid:266) mechanizmu async/await w platformie .NET (http://blogs.msdn.com/b/pfxteam/archive/2012/04/12/10293335.aspx). 4 Warto zwróci(cid:252) uwag(cid:266) na przyrostek „Async”. W ko(cid:276)cu jest to teraz metoda, która dzia(cid:225)a asynchronicznie, cho(cid:252) (cid:298)adnego zadania nie tworzy. Kup książkęPoleć książkę Rozdzia(cid:228) 1. (cid:105) Dla niecierpliwych: asynchroniczno(cid:264)(cid:232) i p(cid:246)tla równoleg(cid:228)a 19 Listing 1.7. Metoda async zwracaj(cid:261)ca warto(cid:286)(cid:252) long private async Task long DoSomethingMoreAsync() { msgBox( DoSomethingMoreAsync: Pocz(cid:230)tek ); long wynik = await DoSomethingAsync( async/await ); msgBox( DoSomethingMoreAsync: Wynik: + wynik.ToString()); msgBox( DoSomethingMoreAsync: Koniec ); return wynik; } private async void button2_Click(object sender, EventArgs e) { msgBox( button2_Click: Pocz(cid:230)tek ); msgBox( button2_Click: Wynik: + await DoSomethingMoreAsync()); msgBox( button2_Click: Koniec ); } I kolejna sprawa. Co w metodach async dzieje si(cid:266) w przypadku b(cid:225)(cid:266)dów? Nieobs(cid:225)u(cid:298)o- ne wyj(cid:261)tki zg(cid:225)oszone w metodzie z modyfikatorem async i zwracaj(cid:261)ce zadania (Task lub Task ) s(cid:261) za po(cid:286)rednictwem tych zada(cid:276) przekazywane do metody wywo(cid:225)uj(cid:261)cej. Mo(cid:298)na zatem u(cid:298)y(cid:252) normalnej konstrukcji try..catch, jak na listingu 1.8. Gorzej jest w przypadku metod async zwracaj(cid:261)cych void (typu „wystrzel i zapomnij”, jak button1_ (cid:180)Click z naszego przyk(cid:225)adu). Wówczas wyj(cid:261)tek przekazywany jest do puli w(cid:261)tków kryj(cid:261)cej si(cid:266) za mechanizmem zada(cid:276) i przechwytywanie wyj(cid:261)tków nic nie da. Listing 1.8. Obs(cid:225)uga wyj(cid:261)tków zg(cid:225)aszanych przez metody async private async void button2_Click(object sender, EventArgs e) { msgBox( button2_Click: Pocz(cid:230)tek ); try { msgBox( button2_Click: Wynik: + await DoSomethingMoreAsync()); } catch(Exception exc) { msgBox( button2_Click: B(cid:273)(cid:230)d!\n + exc.Message); } msgBox( button2_Click: Koniec ); } Klasa Parallel z biblioteki TPL (nowo(cid:264)(cid:232) platformy .NET 4.0) Do platformy .NET w wersji 4.0 dodana zosta(cid:225)a biblioteka TPL (ang. Task Parallel Library), która wraz ze zrównoleglonym PLINQ i kolekcjami przystosowanymi do konkurencyjnej obs(cid:225)ugi sk(cid:225)ada si(cid:266) na tzw. Parallel Extensions. Biblioteka TPL nad- budowuje klasyczne w(cid:261)tki, korzystaj(cid:261)c z poznanej ju(cid:298) przed chwil(cid:261) klasy Task (z ang. Kup książkęPoleć książkę 20 Programowanie równoleg(cid:228)e i asynchroniczne w C# 5.0 zadanie). Biblioteka ta zostanie dok(cid:225)adnie opisana w nast(cid:266)pnych rozdzia(cid:225)ach. Tu chcia(cid:225)- bym skupi(cid:252) si(cid:266) tylko na najcz(cid:266)(cid:286)ciej u(cid:298)ywanym jej elemencie — implementacji wspó(cid:225)- bie(cid:298)nej p(cid:266)tli For. Równoleg(cid:228)a p(cid:246)tla For Za(cid:225)ó(cid:298)my, (cid:298)e mamy zbiór stu liczb rzeczywistych, dla których musimy wykona(cid:252) jakie(cid:286) stosunkowo czasoch(cid:225)onne czynno(cid:286)ci. W naszym przyk(cid:225)adzie b(cid:266)dzie to obliczanie warto(cid:286)ci funkcji f(x) = arcsin(sin(x)). Funkcja ta powinna z dok(cid:225)adno(cid:286)ci(cid:261) numeryczn(cid:261) zwróci(cid:252) warto(cid:286)(cid:252) argumentu x. Zrobi to, ale nie(cid:296)le si(cid:266) przy tym nam(cid:266)czy — funkcje trygonometryczne s(cid:261) do(cid:286)(cid:252) wymagaj(cid:261)ce numerycznie. Dodatkowo powtórzymy te obli- czenia kilkakrotnie, aby jeszcze bardziej wyd(cid:225)u(cid:298)y(cid:252) czas oblicze(cid:276). Kod odpowiedniej metody z projektu aplikacji konsolowej widoczny jest na listingu 1.9. Listing 1.9. Metoda zajmuj(cid:261)ca procesor private static double obliczenia(double argument) { for (int i = 0; i 10; ++i) argument = Math.Asin(Math.Sin(argument)); return argument; } Z kolei na listingu 1.10 widoczna jest p(cid:266)tla wykonuj(cid:261)ca owe obliczenia wraz z przy- gotowaniem tablicy z wynikami. Wyniki te nie s(cid:261) jednak drukowane — tablica jest zbyt du(cid:298)a, (cid:298)eby to mia(cid:225)o sens. Poni(cid:298)szy kod zawiera dwie zagnie(cid:298)d(cid:298)one p(cid:266)tle For. Interesuje nas tylko wewn(cid:266)trzna. Zadaniem zewn(cid:266)trznej jest wielokrotne powtórzenie oblicze(cid:276), co pozwoli nam bardziej wiarygodnie zmierzy(cid:252) czas oblicze(cid:276). Pomiary te reali- zujemy na bazie zliczania taktów procesora (System.Environment.TickCount). Listing 1.10. Obliczenia sekwencyjne static void Main(string[] args) { //przygotowania int rozmiar = 10000; Random r = new Random(); double[] tablica = new double[rozmiar]; for(int i=0;i tablica.Length;++i) tablica[i] = r.NextDouble(); //obliczenia sekwencyjne int iloscPowtorzen = 100; double[] wyniki = new double[tablica.Length]; int start = System.Environment.TickCount; for(int powtorzenia = 0; powtorzenia iloscPowtorzen;++powtorzenia) for(int i=0;i tablica.Length; ++i) wyniki[i] = obliczenia(tablica[i]); int stop = System.Environment.TickCount; Console.WriteLine( Obliczenia sekwencyjne trwa(cid:273)y (cid:180)+ (stop - start).ToString() + ms. ); /* //prezentacja wyników Kup książkęPoleć książkę Rozdzia(cid:228) 1. (cid:105) Dla niecierpliwych: asynchroniczno(cid:264)(cid:232) i p(cid:246)tla równoleg(cid:228)a 21 string s = Wyniki:\n ; for(int i=0;i tablica.Length;++i) s += i + . + tablica[i] + ?= + wyniki[i] + \n ; Console.WriteLine(s); */ } Przy u(cid:298)yciu klasy Parallel z przestrzeni nazw System.Threading.Tasks mo(cid:298)na bez wi(cid:266)kszego wysi(cid:225)ku zrównolegli(cid:252) p(cid:266)tl(cid:266) for z metody Main (t(cid:266) z indeksem i). Pokazuje to kod z listingu 1.11. Nale(cid:298)y go doda(cid:252) do metody z listingu 1.10. Listing 1.11. Przyk(cid:225)ad zrównoleglonej p(cid:266)tli for //obliczenia równoleg(cid:225)e start = System.Environment.TickCount; for(int powtorzenia = 0; powtorzenia iloscPowtorzen; ++powtorzenia) Parallel.For(0, tablica.Length, i= { wyniki[i] = obliczenia(tablica[i]); }); stop = System.Environment.TickCount; Console.WriteLine( Obliczenia równoleg(cid:273)e trwa(cid:273)y + (stop - start).ToString() + ms. ); Metoda Parallel.For jest do(cid:286)(cid:252) intuicyjna w u(cid:298)yciu. Jej dwa pierwsze argumenty okre- (cid:286)laj(cid:261) zakres zmiany indeksu p(cid:266)tli. W naszym przypadku jest on równy [0,1000). Wo- bec tego do metody podanej w trzecim argumencie przekazywane s(cid:261) liczby od 0 do 999. Trzeci argument jest delegatem, do którego mo(cid:298)na przypisa(cid:252) metod(cid:266) lub, jak w naszym przypadku, wyra(cid:298)enie lambda wywo(cid:225)ywane w ka(cid:298)dej iteracji p(cid:266)tli. Powinna si(cid:266) tam zatem znale(cid:296)(cid:252) zawarto(cid:286)(cid:252) oryginalnej p(cid:266)tli. Metoda Parallel.For automatycznie synchronizuje u(cid:298)ywane przez ni(cid:261) zadania przed zako(cid:276)czeniem, dlatego nie ma zagro(cid:298)enia zamazania danych w ramach kolejnych powtó- rze(cid:276) (zewn(cid:266)trzna p(cid:266)tla for). To, (cid:298)e tworzenie równoleg(cid:225)ej p(cid:266)tli Parallel.For jest, jak to mówi(cid:261) Anglicy, out of the box, nie oznacza, (cid:298)e automatycznie unikamy wszystkich problemów, jakie w równole- g(cid:225)ych p(cid:266)tlach mog(cid:261) powsta(cid:252). Szczególnie nale(cid:298)y zwróci(cid:252) uwag(cid:266) na spraw(cid:266) podsta- wow(cid:261): mi(cid:266)dzy iteracjami p(cid:266)tli nie mo(cid:298)e by(cid:252) rekurencyjnej zale(cid:298)no(cid:286)ci, a wi(cid:266)c kolejna iteracja nie mo(cid:298)e zale(cid:298)e(cid:252) od warto(cid:286)ci jakie(cid:286) zmiennej policzonej w poprzedniej iteracji. Iteracje w równoleg(cid:225)ej p(cid:266)tli nie s(cid:261) przecie(cid:298) wykonywane w kolejno(cid:286)ci indeksów. Na- le(cid:298)y tak(cid:298)e uwa(cid:298)a(cid:252) na ukryte zale(cid:298)no(cid:286)ci rekurencyjne. Przyk(cid:225)adem, w którym kryj(cid:261) si(cid:266) takie zale(cid:298)no(cid:286)ci, jest cho(cid:252)by klasa Random. Nie nale(cid:298)y si(cid:266) spodziewa(cid:252), (cid:298)e dzi(cid:266)ki u(cid:298)yciu równoleg(cid:225)ej p(cid:266)tli nasze obliczenia przy- spiesz(cid:261) tyle razy, ile rdzeni procesora mamy do dyspozycji. Tworzenie i usuwanie zada(cid:276) równie(cid:298) zajmuje nieco czasu. Eksperymentuj(cid:261)c z rozmiarem tablicy i liczb(cid:261) oblicza- nych sinusów, mo(cid:298)na sprawdzi(cid:252), (cid:298)e zrównoleglanie op(cid:225)aca si(cid:266) tym bardziej, im d(cid:225)u(cid:298)sze s(cid:261) obliczenia wykonywane w ramach jednego zadania. Dla krótkich zada(cid:276) u(cid:298)ycie rów- noleg(cid:225)ej p(cid:266)tli mo(cid:298)e wr(cid:266)cz wyd(cid:225)u(cid:298)y(cid:252) ca(cid:225)kowity czas oblicze(cid:276). W moich testach na kom- puterze z jednym procesorem dwurdzeniowym czas oblicze(cid:276) zmniejszy(cid:225) si(cid:266) do mniej wi(cid:266)cej (cid:1152) czasu oblicze(cid:276) sekwencyjnych. Z kolei przy a(cid:298) o(cid:286)miu rdzeniach czas obli- cze(cid:276) równoleg(cid:225)ych spad(cid:225) tylko do nieco ponad (cid:1151). Kup książkęPoleć książkę 22 Programowanie równoleg(cid:228)e i asynchroniczne w C# 5.0 Przedstawione w tym rozdziale informacje o klasie Parallel i jej metodzie For na- le(cid:276)y traktowa(cid:232) jedynie jako zapowied(cid:274) rozdzia(cid:228)u 7., w którym klasa ta zostanie omówiona bardziej wyczerpuj(cid:241)co. Przerywanie p(cid:246)tli Podobnie jak w klasycznej p(cid:266)tli for, równie(cid:298) w jej równoleg(cid:225)ej wersji mo(cid:298)emy w ka(cid:298)dej chwili przerwa(cid:252) dzia(cid:225)anie p(cid:266)tli. S(cid:225)u(cid:298)y do tego klasa ParallelLoopState, która mo(cid:298)e by(cid:252) przekazana w dodatkowym argumencie metody wykonywanej w ka(cid:298)dej iteracji. Klasa ta udost(cid:266)pnia dwie wa(cid:298)ne metody: Break i Stop. Ró(cid:298)ni(cid:261) si(cid:266) one tym, (cid:298)e pierwsza pozwala na wcze(cid:286)niejsze zako(cid:276)czenie bie(cid:298)(cid:261)cej iteracji, a nast(cid:266)pne nie b(cid:266)d(cid:261) ju(cid:298) uru- chamiane, podczas gdy metoda Stop nie tylko natychmiast ko(cid:276)czy bie(cid:298)(cid:261)ce zadanie, ale równie(cid:298) podnosi flag(cid:266) IsStopped, która mo(cid:298)e by(cid:252) sprawdzona we wszystkich uru- chomionych wcze(cid:286)niej iteracjach, co powinno by(cid:252) dla nich sygna(cid:225)em do zako(cid:276)czenia dzia(cid:225)ania (je(cid:298)eli programista uwzgl(cid:266)dni to w ich kodzie). Na listingu 1.12 pokazuj(cid:266) przyk(cid:225)ad, w którym p(cid:266)tla jest przerywana, je(cid:298)eli wylosowana zostanie liczba 0. Listing 1.12. Przerywanie p(cid:266)tli równoleg(cid:225)ej private static void przerywaniePetli() { Random r = new Random(); long suma = 0; long licznik = 0; string s = ; //iteracje zostan(cid:261) wykonane tylko dla liczb parzystych //p(cid:266)tla zostanie przerwana wcze(cid:286)niej, je(cid:298)eli wylosowana liczba jest wi(cid:266)ksza od 90 Parallel.For( 0, 10000, (int i, ParallelLoopState stanPetli) = { int liczba = r.Next(7); //losowanie liczby oczek na kostce if(liczba == 0) { s += 0 (Stop); ; stanPetli.Stop(); } if(stanPetli.IsStopped) return; if(liczba 2 == 0) { s += liczba.ToString() + ; ; obliczenia(liczba); suma += liczba; licznik += 1; } else { s += liczba.ToString() + ; ; } }); Kup książkęPoleć książkę Rozdzia(cid:228) 1. (cid:105) Dla niecierpliwych: asynchroniczno(cid:264)(cid:232) i p(cid:246)tla równoleg(cid:228)a 23 Console.WriteLine( Wylosowane liczby: + s + \n + Liczba pasuj(cid:230)cych liczb: + licznik + \n + Suma: + suma + \n + (cid:294)rednia: + (suma / (double)licznik).ToString()); } Kup książkęPoleć książkę 24 Programowanie równoleg(cid:228)e i asynchroniczne w C# 5.0 Kup książkęPoleć książkę Skorowidz A B ActiveX, 124 adres http, 256 URL, 256 agregacja kolekcji równoleg(cid:225)ych, 199 Albahari Joe, 64 algorytm braci Borwein, 47 spigot, 47 Apartment Threaded Model, Patrz: ATM aplikacja desktopowa, 95, 124, 215, 251 domena, Patrz: domena aplikacji GitHub, 302 instancja, 89 kliencka, 302 konsolowa, 26, 28, 80, 215, 237, 307, 339, 397 przebieg pracy, 419 równoleg(cid:225)a, 225 profiler, 225, 232 rysuj(cid:261)ca, 350 sieciowa, 215 webowa, 237 wielow(cid:261)tkowa, 40, 187, 189, 407, 411 Windows Forms, 96, 104, 105 Windows Store, 397 WinRT, 397 WPF, 116, 219 z interfejsem graficznym, 397 async method, 16 ATI Stream, 365 ATM, 124 BackgroundWorker, 110, 114 bariera, 86, 104, 184 Bart de Smet, 346 Base Class Library, Patrz: BCL Basic Linear Algebra Subprograms, Patrz: BLAS baz(cid:261) danych SQL, 212 BCL, 303 bezpiecze(cid:276)stwo, 40, 77, 104, 124, 419 biblioteka Bing Search API, 355 BLAS, Patrz: BLAS CCR, Patrz: CCR cuBLAS, 394 CUDAfy.Net, 376 CUDAfy.NET, 366 Cudafy.NET.dll, 371 cuFFT, 392 cuRAND, 390, 392 DLL, 404 DSS, Patrz: DSS Kinect for Windows, 246 klas podstawowa, Patrz: BCL kontrolek WPF, 345 licencja, 423 Microsoft Silverlight, 246 Portable Class Library, 307 ReactiveCocoa, Patrz: ReactiveCocoa Rx, Patrz: Rx System.Data.Services.Client.dll, 357 TPL, Patrz: TPL Windows Forms, 96 Bing, 345, 353, 357 Kup książkęPoleć książkę 428 Programowanie równoleg(cid:228)e i asynchroniczne w C# 5.0 Bing Search API, 353 BLAS, 394 blokada, 77, 179, 181, 188, 191 wiruj(cid:261)ca, 45 broadcast, Patrz: rozg(cid:225)aszanie C C for CUDA, 365 callback function, Patrz: funkcja odpowiedzi CCR, 243, 244, 249, 276, 277, 291, 298 CLR, 31 cold observable, Patrz: obserwabla zimna COM, 124 Common Language Runtime, Patrz: CLR Component Object Model, Patrz: COM compute capability, Patrz: karta graficzna potencja(cid:225) obliczeniowy Compute Unified Device Architecture, Concurrency and Coordination Runtime, Patrz: CUDA Patrz: CCR Concurrency Visualizer, 225, 232, 237 Console Application, Patrz: aplikacja konsolowa CUDA, 365 CUDAfy.NET, 366, 368, 376 czas oblicze(cid:276), 20, 383 wirtualny, 334, 335 D dane metody przekszta(cid:225)caj(cid:261)ce, 208 partycjonowanie, 175 podzia(cid:225), 205, 213 przekazywane do zadania, 140 przesy(cid:225)anie do w(cid:261)tku, 45 spychane, 303 SQL, 212 struktura wspó(cid:225)bie(cid:298)na, 187, 188 w programowaniu równoleg(cid:225)ym, 187, 188 wspó(cid:225)dzielone przez w(cid:261)tki, 40, 187 wyci(cid:261)ganie, 302 zwracane przez zadanie, 141 DCOM, 124 deadlock, Patrz: zakleszczenie debugowanie, 93, 148, 225, 227 Decentralized Software Services, Patrz: DSS dekompilator ILSpy, Patrz: ILSpy delegat, 108, 110, 138 diagram koralikowy, 315, 316, 320 dokumentacja MSDN, 16, 33, 149, 155, 205, 399 domena aplikacji, 31 DSS, 243, 244, 249, 276, 277, 291, 298 konsola Command Prompt, 293 E edytor XAML, Patrz: XAML Euler Leonhard, 47 extension method, Patrz: metoda rozszerzaj(cid:261)ca F factory method, Patrz: metoda tworz(cid:261)ca FFT, 392 FIFO, Patrz: kolejka FIFO flaga, 34, 239, 302 IsStopped, 22 Fouriera transformata szybka, Patrz: FFT funkcja odpowiedzi, 302 WinAPI InterlockedAdd, 52 G General-Purpose computing on Graphics Processor Units, Patrz: GPGPU generator liczb losowych, 36, 37 pseudolosowych, 59, 390, 392 GPGPU, 365 GPU, 365, 372 emulator, 375 u(cid:298)ytkownika Graphical User Interface, Patrz: interfejs GUI, Patrz: interfejs:u(cid:298)ytkownika H Hadamarda iloczyn, 378 hot observable, Patrz: obserwabla gor(cid:261)ca Hybrid DSP, 366 I identyfikator kontraktu, 245 sekcji krytycznej, 44 us(cid:225)ugi, 245 Kup książkęPoleć książkę Skorowidz 429 iloczyn Hadamarda, 378 po wspó(cid:225)rz(cid:266)dnych, 378 Schura, 378 ILSpy, 368, 369 inicjacja leniwa, Patrz: inicjacja z opó(cid:296)nieniem z opó(cid:296)nieniem, 60, 61, 62, 63 aplikacji, Patrz: aplikacja instancja programu, 31, Patrz te(cid:298): w(cid:261)tek instancja interfejs graficzny, 397 ICollection, 304 IEnumerable, 156, 188, 203, 304 IEnumerator, 304 implementacja, 309 IObservable, 303, 304, 305, 309, 315, 316, 334, 346 IObserver, 303, 305, 309, 312, 315, 334 IProducerConsumerCollection, 78, 155, 187, 188, 191, 193, 195 IScheduler, 334 stron internetowych, 251 u(cid:298)ytkownika, 95, 96 aktualizacja, 110 w(cid:261)tek, Patrz: w(cid:261)tek interfejsu u(cid:298)ytkownika J j(cid:261)dro, Patrz: kernel j(cid:266)zyk XAML, Patrz: XAML K karta graficzna, 365, 371, 376, 390 czas oblicze(cid:276), 383 pami(cid:266)(cid:252), 380, 381, 387 potencja(cid:225) obliczeniowy, 368, 370, 375 uchwyt, 372 kernel, 366, 372, 373, 386 wywo(cid:225)anie, 373, 374 Kinect, 246 klasa AutoResetEvent, 85, 184 BackgroundWorker, 111 Barrier, 86, 88 BlockingCollection, 78, 190, 191, 192 CancellationToken, 145, 154, 166, 209 CancellationTokenSource, 209 ConcurrentBag, 188, 189 ConcurrentDictionary, 188 ConcurrentQueue, 188, 190 ConcurrentStack, 188, 190 CountdownEvent, 51 CudafyHost, 372, 376 CudafyModule, 372 CudafyTranslator, 369, 373 Dictionary, 337 Dispatcher, 345 DispatcherTimer, 402 EnlightenmentProvider, 343 Enumerable, 204 EventWaitHandle, 85, 184 FFTPlan1D, 392 GPGPU, 372, 384 GPGPUProperties, 376 GThread, 378, 388 HttpClient, 16 instancja, 45 Interlocked, 64, 188, 412 Lazy, 60 leniwa, 61 List, 399 ManualResetEvent, 85, 184 ManualResetEventSlim, 184 Monitor, 44, 50, 413 Mutex, 88, 89 Observable, 316, 339 odpowiedzialna za obs(cid:225)ug(cid:266) plików, 16 Parallel, 22, 138, 161, 403 ParallelEnumerable, 199, 203 ParallelLoopResult, 168 ParallelLoopState, 22, 168 ParallelOptions, 166 ParallelQuery, 199 Partitioner, 175, 187 Queue, 189 Random, 21 ReaderWriterLock, 73 ReaderWriterLockSlim, 73, 77 SemaphorSlim, 93 SpinLock, 45 Stack, 189 statyczna, 49, 316 StorageFile, 16 StreamReader, 16 StremWriter, 16 SynchronizationContext, 128, 334, 345 Kup książkęPoleć książkę 430 Programowanie równoleg(cid:228)e i asynchroniczne w C# 5.0 klasa System.Threading.Interlocked, 52, 53 System.Threading.LazyInitializer, 63 System.Threading.Timer, 54 Task, 13, 19, 138, 144, 398, 399, 400 TaskContinuationOptions, 154 TaskCreationOptions, 154 TaskFactory, 138, 144, 152, 153 TaskScheduler, 138, 154, 155 Thread, 29, 334, 399, 400 ThreadPool, 48, 343, 401 ThreadPoolTimer, 402 Timer, 402 WCF, 16 WindowsFormsSynchronizationContext, 130 XmlReader, 16 klaster obliczeniowy, 277 kod XAML, 116 kolejka FIFO, 155, 156, 189, 191 wiadomo(cid:286)ci, 244 wspó(cid:225)bie(cid:298)na, 189 kolekcja, 189, 191 równoleg(cid:225)a, 199 wspó(cid:225)bie(cid:298)na, 189, 193 w(cid:225)asna, 193, 195 kompilator, 18 C#, 64 JIT, 64 komponent wizualny, 124 komunikat, 239, 251 konsola DSS Command Prompt, 293 Xbox 360, 404 kontrolka, 103, 108, 110, 215, 339 BackgroundWorker, 25 Timer, 25 WPF, 345 kursor myszy, 346, 348 L Language INtegrated Query, Patrz: LINQ Lego Mindstorms, 243, 249 liczba losowa, 37 pierwsza, 141, 215 (cid:652), 25, 47, 115, 170, 277 LIFO, Patrz: stos linia obrazu, 95, 99 LINQ, 203, 205, 209, 212, 301, 315 do zdarze(cid:276), 302, 306, 315, 316 lock, Patrz: blokada log, 419 M macierz, 378, 379, 380, 388, 394 manifest, 251 Manifest Load Results, Patrz: manifest marble diagram, Patrz: diagram koralikowy marmurki, 315 maszyna wirtualna, 31 MATLAB, 365 metoda Add, 191 Aggregate, 199 AllocateShared, 388 AsOrdered, 208, 209 AsParallel, 138, 199, 209 AsSequential, 209 AsUnordered, 208, 209 async, 18 b(cid:225)(cid:266)dy, 19 zwracaj(cid:261)ca warto(cid:286)(cid:252), 18 asynchroniczna, 131 BackgroundWorker.CancelAsync, 110 BackgroundWorker.DoWork, 110, 114 BackgroundWorker.ProgressChanged, 110 BackgroundWorker.RunWorkerAsync, 110 BackgroundWorker.RunWorkerCompleted, 110 blokuj(cid:261)ca, 131, 191, 357 Break, 22 Buffer, 324, 326, 327 Cancel, 210 CancellationTo- ken.ThrowIfCancellationRequested, 146, 147 CancellationTokenSource.Cancel, 145, 168 CombineLatest, 323 Console.WriteLine, 382 ContinueWhenAny, 144 Control.BeginInvoke, 107, 108, 131 Control.Dispatcher.BeginInvoke, 128, 131 Control.Dispatcher.
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Programowanie równoległe i asynchroniczne w C# 5.0
Autor:
, , , , ,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: