Wstęp (9)

Przedmowa (11)

Rozdział 1. Dla niecierpliwych: asynchroniczność i pętla równoległa (13)

• Programowanie asynchroniczne. Operator await i modyfikator async (nowość języka C# 5.0 i platformy .NET 4.5) (13)
• Klasa Parallel z biblioteki TPL (nowość platformy .NET 4.0) (19)
  
  • Równoległa pętla For (20)
  • Przerywanie pętli (22)

Rozdział 2. Wątki (25)

• Monte Carlo (25)
• Obliczenia bez użycia dodatkowych wątków (26)
• Przeniesienie obliczeń do osobnego wątku (28)
• Wątki, procesy i domeny aplikacji (30)
• Usypianie bieżącego wątku (31)
• Przerywanie działania wątku (Abort) (32)
• Wstrzymywanie i wznawiane działania wątku (34)
• Wątki działające w tle (35)
• Zmiana priorytetu wątku (36)
• Użycie wielu wątków i problemy z generatorem liczb pseudolosowych (36)
• Pamięć lokalna wątku i bezpieczeństwo wątku (39)
• Czekanie na ukończenie pracy wątku (Join) (40)
• Sekcje krytyczne (lock) (43)
• Przesyłanie danych do wątku (45)
• Pula wątków (47)
• Jeszcze raz o sygnalizacji zakończenia pracy wątków (50)
• Operacje atomowe (51)
• Tworzenie wątków za pomocą System.Threading. Timer i imitacja timera w wątku z wysokim priorytetem (54)
• Zadania (57)

Rozdział 3. Zmienne w aplikacjach wielowątkowych (59)

• Atrybut ThreadStatic (59)
• Opóźniona inicjacja i zmienne lokalne wątku (60)
• Volatile (64)
• Zadania (65)

Rozdział 4. Więcej o synchronizacji wątków. Blokady i sygnały (67)

• Problem ucztujących filozofów (68)
• Problem czytelników i pisarzy (73)
• Komunikacja między wątkami. Problem producenta i konsumenta (78)
• Sygnalizacja za pomocą metod Monitor.Pulse i Monitor.Wait (81)
• EventWaitHandle i AutoResetEvent (85)
• Bariera (86)
• Synchronizacja wątków z różnych procesów. Muteksy i semafory nazwane (88)
  
  • Kontrola ilości instancji aplikacji (89)
  • Mutex (89)
  • Semafor (91)
• Zadania (93)

Rozdział 5. Wątki a interfejs użytkownika (95)

• Wątki robocze w aplikacjach desktopowych (95)
  
  • Przygotowanie projektu aplikacji oraz danych wejściowych (96)
  • Wykorzystanie wątków w długotrwałych metodach zdarzeniowych (99)
• Synchronizacja wątków z interfejsem użytkownika w aplikacjach Windows Forms (104)
• BackgroundWorker (110)
• Synchronizacja wątków z komponentami Windows Presentation Foundation (114)
  
  • Projekt graficznego interfejsu użytkownika (115)
  • Implementacja metod zdarzeniowych (117)
  • Bezpieczny dostęp do kontrolek WPF (125)
• Kontekst synchronizacji (128)
• Groźba zagłodzenia wątku interfejsu i asynchroniczna zmiana stanu współdzielonych zasobów (135)
• Zadania (136)

Rozdział 6. Zadania (137)

• Tworzenie zadania (137)
• Praca z zadaniami (138)
• Dane przekazywane do zadań (140)
• Dane zwracane przez zadania (141)
• Przykład: test liczby pierwszej (141)
• Synchronizacja zadań (143)
• Przykład: sztafeta zadań (144)
• Przerywanie zadań (145)
• Stan zadania (149)
• Fabryka zadań (152)
• Planista i zarządzanie kolejkowaniem zadań (155)
• Ustawienia zadań (159)
• Zadania (160)

Rozdział 7. Klasa Parallel. Zrównoleglanie pętli (161)

• Równoległa pętla for (162)
• Równoległa pętla foreach (163)
• Metoda Invoke (164)
• Ustawienia pętli równoległych. Klasa ParallelOptions (166)
• Przerywanie pętli za pomocą CancelationToken (166)
• Kontrola wykonywania pętli (168)
• Synchronizacja pętli równoległych. Obliczanie ? metodą Monte Carlo (169)
• Partycjonowanie danych (175)
• Zadania (177)

Rozdział 8. Synchronizacja zadań (179)

• Blokady (lock) (179)
• Sygnały (Monitor.Pulse i Monitor.Wait) (182)
• Bariera (184)

Rozdział 9. Dane w programach równoległych (187)

• Praca ze zbiorami danych w programowaniu równoległym (187)
  
  • Współbieżne struktury danych (187)
  • Kolekcja ConcurrentBag (189)
  • Współbieżne kolejka i stos (189)
  • Praca z BlockingCollection (190)
  • Własna kolekcja współbieżna (193)
  • Agregacja (197)
  • Agregacje dla kolekcji równoległych (199)
• PLINQ - zrównoleglone zapytania LINQ (203)
  
  • Przykład zapytania PLINQ (204)
  • Jak działa PLINQ? (205)
  • Kiedy PLINQ jest wydajne? (207)
  • Metody przekształcające dane wynikowe (208)
  • Przerywanie zapytań (209)
  • Metoda ForAll (212)
• Zadania (213)

Rozdział 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ł 11. Analiza aplikacji wielowątkowych. Debugowanie i profilowanie (225)

• Okno wątków (Threads) (226)
• Okno zadań równoległych (Parallel Tasks) (228)
• Okno stosów równoległych (Parallel Stacks) (229)
• Okno równoległego śledzenia zmiennych (Parallel Watch) (230)
• Concurrency Visualizer (232)
  
  • Widok Wykorzystanie CPU (232)
  • Widok Wątki (233)
  • Widok Rdzenie (236)
  • Profilowanie aplikacji zewnętrznych (237)
  • Znaczniki (238)
• Zadania (241)

Rozdział 12. Wstęp do CCR i DSS (243)

• Instalacja środowiska Microsoft Robotics (245)
  
  • Możliwe problemy z uruchomieniem środowiska Robotics (247)
  • Kompilacja i uruchamianie projektów dołączonych do książki (248)
• CCR i DSS w pigułce (249)
  
  • Czujniki i urządzenia - tworzenie pierwszej usługi (249)
  • Serwisy partnerskie (265)

Rozdział 13. Skalowalne rozwiązanie dla systemów rozproszonych na bazie technologii CCR i DSS (277)

• Opóźnione uruchamianie (291)
• Uruchamianie obliczeń na klastrze (293)
• Podsumowanie (298)
• Zadania (299)

Rozdział 14. Wprowadzenie do Reactive Extensions. Zarządzanie sekwencjami zdarzeń (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ć z interfejsów w Rx? (309)
  • Subskrypcje (312)
  • LINQ do zdarzeń (315)
• Zimne i gorące obserwable (329)

Rozdział 15. Współbieżność w Rx (333)

• Zarządzanie równoległością (333)
  
  • Interfejs IScheduler (334)
  • Planiści (335)
  • Metody SubscribeOn i ObserveOn (339)
  • Słowo o unifikacji (343)

Rozdział 16. Przykłady użycia technologii Rx w aplikacjach WPF (345)

• Rysowanie z użyciem Rx (346)
• Wyszukiwarka (353)

Rozdział 17. CUDA w .NET (365)

• Konfiguracja środowiska dla CUDAfy.NET (366)
• Pierwsze kroki (368)
• Hello World, czyli pierwszy program CUDAfy.NET (370)
• Emulator GPU (375)
• Własności GPU (376)
• Przekazywanie parametrów do kerneli (378)
• Operacje na pamięci globalnej karty graficznej (380)
• Pomiar czasu wykonania (383)
• Dostęp zwarty do pamięci globalnej i pamięć współ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ątków (400)
• Pula wątków (401)
• ThreadPoolTimer (402)
• Podobieństwa (403)
• Przenośna biblioteka (404)
• Zadania (406)

Dodatek B. Dobre praktyki programowania aplikacji wielowątkowych (407)

• Wprowadzenie (407)
• Sekcje krytyczne i zakleszczenia (407)
• Wyścig (411)
• Słowo kluczowe volatile i kontrola pętli wykonywanej w ramach funkcji wątku (417)
• Bezpieczeństwo wątków a konstruktory i pola statyczne (419)

Dodatek C. Menadżer pakietów NuGet (423)

• Instalacja NuGet (423)
• Korzystanie z NuGet (425)

Skorowidz (427)

• Tytuł: Programowanie równoległe i asynchroniczne w C# 5.0
• Autor: Mateusz Warczak, Jacek Matulewski, Rafał Pawłaszek, Piotr Sybilski, Dawid Borycki, Tomasz Dziubak
• ISBN: 978-83-246-8905-7, 9788324689057
• Data wydania: 2013-11-22
• Format: Ebook
• Identyfikator pozycji: proch5
• Wydawca: Helion