Słowo wstępne (11)

Podziękowania (13)

O tej książce (15)

Rozdział 1. Witaj, świecie współbieżności w C++! (19)

• 1.1. Czym jest współbieżność? (20)
  
  • 1.1.1. Współbieżność w systemach komputerowych (20)
  • 1.1.2. Modele współbieżności (22)
• 1.2. Dlaczego warto stosować współbieżność? (25)
  
  • 1.2.1. Stosowanie współbieżności do podziału zagadnień (25)
  • 1.2.2. Stosowanie współbieżności do podniesienia wydajności (26)
  • 1.2.3. Kiedy nie należy stosować współbieżności (27)
• 1.3. Współbieżność i wielowątkowość w języku C++ (28)
  
  • 1.3.1. Historia przetwarzania wielowątkowego w języku C++ (29)
  • 1.3.2. Obsługa współbieżności w nowym standardzie (30)
  • 1.3.3. Efektywność biblioteki wątków języka C++ (30)
  • 1.3.4. Mechanizmy związane z poszczególnymi platformami (32)
• 1.4. Do dzieła! (32)
  
  • 1.4.1. "Witaj świecie współbieżności" (32)
• 1.5. Podsumowanie (34)

Rozdział 2. Zarządzanie wątkami (35)

• 2.1. Podstawowe zarządzanie wątkami (36)
  
  • 2.1.1 Uruchamianie wątku (36)
  • 2.1.2. Oczekiwanie na zakończenie wątku (39)
  • 2.1.3. Oczekiwanie w razie wystąpienia wyjątku (39)
  • 2.1.4. Uruchamianie wątków w tle (42)
• 2.2. Przekazywanie argumentów do funkcji wątku (43)
  
• 2.3. Przenoszenie własności wątku (46)
  
• 2.4. Wybór liczby wątków w czasie wykonywania (49)
  
• 2.5. Identyfikowanie wątków (52)
  
• 2.6. Podsumowanie (54)

Rozdział 3. Współdzielenie danych przez wątki (55)

• 3.1. Problemy związane ze współdzieleniem danych przez wątki (56)
  
  • 3.1.1. Sytuacja wyścigu (58)
  • 3.1.2. Unikanie problematycznych sytuacji wyścigu (59)
• 3.2. Ochrona współdzielonych danych za pomocą muteksów (60)
  
  • 3.2.1. Stosowanie muteksów w języku C++ (60)
  • 3.2.2. Projektowanie struktury kodu z myślą o ochronie współdzielonych danych (62)
  • 3.2.3. Wykrywanie sytuacji wyścigu związanych z interfejsami (63)
  • 3.2.4. Zakleszczenie: problem i rozwiązanie (71)
  • 3.2.5. Dodatkowe wskazówki dotyczące unikania zakleszczeń (73)
  • 3.2.6. Elastyczne blokowanie muteksów za pomocą szablonu std::unique_lock (79)
  • 3.2.7. Przenoszenie własności muteksu pomiędzy zasięgami (80)
  • 3.2.8. Dobór właściwej szczegółowości blokad (82)
• 3.3. Alternatywne mechanizmy ochrony współdzielonych danych (84)
  
  • 3.3.1. Ochrona współdzielonych danych podczas inicjalizacji (84)
  • 3.3.2. Ochrona rzadko aktualizowanych struktur danych (88)
  • 3.3.3. Blokowanie rekurencyjne (90)
• 3.4. Podsumowanie (91)

Rozdział 4. Synchronizacja współbieżnych operacji (93)

• 4.1. Oczekiwanie na zdarzenie lub inny warunek (94)
  
  • 4.1.1. Oczekiwanie na spełnienie warunku za pomocą zmiennych warunkowych (95)
  • 4.1.2. Budowa kolejki gwarantującej bezpieczne przetwarzanie wielowątkowe przy użyciu zmiennych warunkowych (97)
• 4.2. Oczekiwanie na jednorazowe zdarzenia za pomocą przyszłości (102)
  
  • 4.2.1. Zwracanie wartości przez zadania wykonywane w tle (103)
  • 4.2.2. Wiązanie zadania z przyszłością (106)
  • 4.2.3. Obietnice (szablon std::promise) (109)
  • 4.2.4. Zapisywanie wyjątku na potrzeby przyszłości (111)
  • 4.2.5. Oczekiwanie na wiele wątków (112)
• 4.3. Oczekiwanie z limitem czasowym (115)
  
  • 4.3.1. Zegary (115)
  • 4.3.2. Okresy (117)
  • 4.3.3. Punkty w czasie (118)
  • 4.3.4. Funkcje otrzymujące limity czasowe (120)
• 4.4. Upraszczanie kodu za pomocą technik synchronizowania operacji (121)
  
  • 4.4.1. Programowanie funkcyjne przy użyciu przyszłości (122)
  • 4.4.2. Synchronizacja operacji za pomocą przesyłania komunikatów (127)
• 4.5. Podsumowanie (131)

Rozdział 5. Model pamięci języka C++ i operacje na typach atomowych (133)

• 5.1. Podstawowe elementy modelu pamięci (134)
  
  • 5.1.1. Obiekty i miejsca w pamięci (134)
  • 5.1.2. Obiekty, miejsca w pamięci i przetwarzanie współbieżne (135)
  • 5.1.3. Kolejność modyfikacji (136)
• 5.2. Operacje i typy atomowe języka C++ (137)
  
  • 5.2.1. Standardowe typy atomowe (138)
  • 5.2.2. Operacje na typie std::atomic_flag (141)
  • 5.2.3. Operacje na typie std::atomic<bool> (143)
  • 5.2.4. Operacje na typie std::atomic<T*> - arytmetyka wskaźników (146)
  • 5.2.5. Operacje na standardowych atomowych typach całkowitoliczbowych (147)
  • 5.2.6. Główny szablon klasy std::atomic<> (147)
  • 5.2.7. Wolne funkcje dla operacji atomowych (150)
• 5.3. Synchronizacja operacji i wymuszanie ich porządku (151)
  
  • 5.3.1. Relacja synchronizacji (152)
  • 5.3.2. Relacja poprzedzania (154)
  • 5.3.3. Porządkowanie pamięci na potrzeby operacji atomowych (155)
  • 5.3.4. Sekwencje zwalniania i relacja synchronizacji (175)
  • 5.3.5. Ogrodzenia (178)
  • 5.3.6. Porządkowanie operacji nieatomowych za pomocą operacji atomowych (180)
• 5.4. Podsumowanie (182)

Rozdział 6. Projektowanie współbieżnych struktur danych przy użyciu blokad (183)

• 6.1. Co oznacza projektowanie struktur danych pod kątem współbieżności? (184)
  
  • 6.1.1. Wskazówki dotyczące projektowania współbieżnych struktur danych (185)
• 6.2. Projektowanie współbieżnych struktur danych przy użyciu blokad (186)
  
  • 6.2.1. Stos gwarantujący bezpieczeństwo przetwarzania wielowątkowego przy użyciu blokad (187)
  • 6.2.2. Kolejka gwarantująca bezpieczeństwo przetwarzania wielowątkowego przy użyciu blokad i zmiennych warunkowych (190)
  • 6.2.3. Kolejka gwarantująca bezpieczeństwo przetwarzania wielowątkowego przy użyciu szczegółowych blokad i zmiennych warunkowych (194)
• 6.3. Projektowanie złożonych struktur danych przy użyciu blokad (207)
  
  • 6.3.1. Implementacja tablicy wyszukiwania gwarantującej bezpieczeństwo przetwarzania wielowątkowego przy użyciu blokad (207)
  • 6.3.2. Implementacja listy gwarantującej bezpieczeństwo przetwarzania wielowątkowego przy użyciu blokad (213)
• 6.4. Podsumowanie (218)

Rozdział 7. Projektowanie współbieżnych struktur danych bez blokad (219)

• 7.1. Definicje i ich praktyczne znaczenie (220)
  
  • 7.1.1. Rodzaje nieblokujących struktur danych (220)
  • 7.1.2. Struktury danych bez blokad (221)
  • 7.1.3. Struktury danych bez oczekiwania (222)
  • 7.1.4. Zalety i wady struktur danych bez blokad (222)
• 7.2. Przykłady struktur danych bez blokad (223)
  
  • 7.2.1. Implementacja stosu gwarantującego bezpieczeństwo przetwarzania wielowątkowego bez blokad (224)
  • 7.2.2. Eliminowanie niebezpiecznych wycieków - zarządzanie pamięcią w strukturach danych bez blokad (228)
  • 7.2.3. Wykrywanie węzłów, których nie można odzyskać, za pomocą wskaźników ryzyka (233)
  • 7.2.4. Wykrywanie używanych węzłów metodą zliczania referencji (242)
  • 7.2.5. Zmiana modelu pamięci używanego przez operacje na stosie bez blokad (247)
  • 7.2.6. Implementacja kolejki gwarantującej bezpieczeństwo przetwarzania wielowątkowego bez blokad (252)
• 7.3. Wskazówki dotyczące pisania struktur danych bez blokad (264)
  
  • 7.3.1. Wskazówka: na etapie tworzenia prototypu należy stosować tryb std::memory_order_seq_cst (265)
  • 7.3.2. Wskazówka: należy używać schematu odzyskiwania pamięci bez blokad (265)
  • 7.3.3 Wskazówka: należy unikać problemu ABA (266)
  • 7.3.4. Wskazówka: należy identyfikować pętle aktywnego oczekiwania i wykorzystywać czas bezczynności na wspieranie innego wątku (267)
• 7.4. Podsumowanie (267)

Rozdział 8. Projektowanie współbieżnego kodu (269)

• 8.1. Techniki dzielenia pracy pomiędzy wątki (270)
  
  • 8.1.1. Dzielenie danych pomiędzy wątki przed rozpoczęciem przetwarzania (271)
  • 8.1.2. Rekurencyjne dzielenie danych (272)
  • 8.1.3. Dzielenie pracy według typu zadania (276)
• 8.2. Czynniki wpływające na wydajność współbieżnego kodu (279)
  
  • 8.2.1. Liczba procesorów (280)
  • 8.2.2. Współzawodnictwo o dane i ping-pong bufora (281)
  • 8.2.3. Fałszywe współdzielenie (284)
  • 8.2.4. Jak blisko należy rozmieścić dane? (285)
  • 8.2.5. Nadsubskrypcja i zbyt intensywne przełączanie zadań (285)
• 8.3. Projektowanie struktur danych pod kątem wydajności przetwarzania wielowątkowego (286)
  
  • 8.3.1. Podział elementów tablicy na potrzeby złożonych operacji (287)
  • 8.3.2. Wzorce dostępu do danych w pozostałych strukturach (289)
• 8.4. Dodatkowe aspekty projektowania współbieżnych struktur danych (291)
  
  • 8.4.1. Bezpieczeństwo wyjątków w algorytmach równoległych (291)
  • 8.4.2. Skalowalność i prawo Amdahla (298)
  • 8.4.3. Ukrywanie opóźnień za pomocą wielu wątków (300)
  • 8.4.4. Skracanie czasu reakcji za pomocą technik przetwarzania równoległego (301)
• 8.5. Projektowanie współbieżnego kodu w praktyce (303)
  
  • 8.5.1. Równoległa implementacja funkcji std::for_each (304)
  • 8.5.2. Równoległa implementacja funkcji std::find (306)
  • 8.5.3. Równoległa implementacja funkcji std::partial_sum (312)
• 8.6. Podsumowanie (322)

Rozdział 9. Zaawansowane zarządzanie wątkami (323)

• 9.1. Pule wątków (324)
  
  • 9.1.1. Najprostsza możliwa pula wątków (324)
  • 9.1.2. Oczekiwanie na zadania wysyłane do puli wątków (327)
  • 9.1.3. Zadania oczekujące na inne zadania (330)
  • 9.1.4. Unikanie współzawodnictwa w dostępie do kolejki zadań (333)
  • 9.1.5. Wykradanie zadań (335)
• 9.2. Przerywanie wykonywania wątków (340)
  
  • 9.2.1. Uruchamianie i przerywanie innego wątku (340)
  • 9.2.2. Wykrywanie przerwania wątku (342)
  • 9.2.3. Przerywanie oczekiwania na zmienną warunkową (343)
  • 9.2.4. Przerywanie oczekiwania na zmienną typu std::condition_variable_any (346)
  • 9.2.5. Przerywanie pozostałych wywołań blokujących (348)
  • 9.2.6. Obsługa przerwań (349)
  • 9.2.7. Przerywanie zadań wykonywanych w tle podczas zamykania aplikacji (350)
• 9.3. Podsumowanie (352)

Rozdział 10. Testowanie i debugowanie aplikacji wielowątkowych (353)

• 10.1. Rodzaje błędów związanych z przetwarzaniem współbieżnym (354)
  
  • 10.1.1. Niechciane blokowanie (354)
  • 10.1.2. Sytuacje wyścigu (355)
• 10.2. Techniki lokalizacji błędów związanych z przetwarzaniem współbieżnym (357)
  
  • 10.2.1. Przeglądanie kodu w celu znalezienia ewentualnych błędów (357)
  • 10.2.2. Znajdowanie błędów związanych z przetwarzaniem współbieżnym poprzez testowanie kodu (359)
  • 10.2.3. Projektowanie kodu pod kątem łatwości testowania (361)
  • 10.2.4. Techniki testowania wielowątkowego kodu (363)
  • 10.2.5. Projektowanie struktury wielowątkowego kodu testowego (366)
  • 10.2.6. Testowanie wydajności wielowątkowego kodu (369)
• 10.3. Podsumowanie (370)

Dodatek A Krótki przegląd wybranych elementów języka C++11 (371)

• A.1. Referencje do r-wartości (371)
  
  • A.1.1. Semantyka przenoszenia danych (372)
  • A.1.2. Referencje do r-wartości i szablony funkcji (375)
• A.2. Usunięte funkcje (376)
  
• A.3. Funkcje domyślne (377)
  
• A.4. Funkcje constexpr (381)
  
  • A.4.1. Wyrażenia constexpr i typy definiowane przez użytkownika (382)
  • A.4.2. Obiekty constexpr (385)
  • A.4.3. Wymagania dotyczące funkcji constexpr (385)
  • A.4.4. Słowo constexpr i szablony (386)
• A.5. Funkcje lambda (386)
  
  • A.5.1. Funkcje lambda odwołujące się do zmiennych lokalnych (388)
• A.6. Szablony zmiennoargumentowe (391)
  
  • A.6.1. Rozwijanie paczki parametrów (392)
• A.7. Automatyczne określanie typu zmiennej (395)
  
• A.8. Zmienne lokalne wątków (396)
  
• A.9. Podsumowanie (397)

Dodatek B Krótkie zestawienie bibliotek przetwarzania współbieżnego (399)

Dodatek C Framework przekazywania komunikatów i kompletny przykład implementacji systemu bankomatu (401)

Dodatek D Biblioteka wątków języka C++ (419)

• D.1. Nagłówek <chrono> (419)
  
  • D.1.1. Szablon klasy std::chrono::duration (420)
  • D.1.2. Szablon klasy std::chrono::time_point (429)
  • D.1.3. Klasa std::chrono::system_clock (431)
  • D.1.4. Klasa std::chrono::steady_clock (433)
  • D.1.5. Definicja typu std::chrono::high_resolution_clock (435)
• D.2. Nagłówek <condition_variable> (435)
  
  • D.2.1. Klasa std::condition_variable (436)
  • D.2.2. Klasa std::condition_variable_any (444)
• D.3. Nagłówek <atomic> (452)
  
  • D.3.1. Definicje typów std::atomic_xxx (454)
  • D.3.2. Makra ATOMIC_xxx_LOCK_FREE (454)
  • D.3.3. Makro ATOMIC_VAR_INIT (455)
  • D.3.4. Typ wyliczeniowy std::memory_order (455)
  • D.3.5. Funkcja std::atomic_thread_fence (456)
  • D.3.6. Funkcja std::atomic_signal_fence (457)
  • D.3.7. Klasa std::atomic_flag (457)
  • D.3.8. Szablon klasy std::atomic (460)
  • D.3.9. Specjalizacje szablonu std::atomic (471)
  • D.3.10. Specjalizacje szablonu std::atomic<typ-całkowitoliczbowy> (472)
• D.4. Nagłówek <future> (489)
  
  • D.4.1. Szablon klasy std::future (490)
  • D.4.2. Szablon klasy std::shared_future (495)
  • D.4.3. Szablon klasy std::packaged_task (501)
  • D.4.4. Szablon klasy std::promise (507)
  • D.4.5. Szablon funkcji std::async (513)
• D.5. Nagłówek <mutex> (514)
  
  • D.5.1. Klasa std::mutex (515)
  • D.5.2. Klasa std::recursive_mutex (518)
  • D.5.3. Klasa std::timed_mutex (520)
  • D.5.4. Klasa std::recursive_timed_mutex (524)
  • D.5.5. Szablon klasy std::lock_guard (529)
  • D.5.6. Szablon klasy std::unique_lock (530)
  • D.5.7. Szablon funkcji std::lock (540)
  • D.5.8. Szablon funkcji std::try_lock (541)
  • D.5.9. Klasa std::once_flag (541)
  • D.5.10. Szablon funkcji std::call_once (542)
• D.6. Nagłówek <ratio> (543)
  
  • D.6.1. Szablon klasy std::ratio (544)
  • D.6.2. Alias szablonu std::ratio_add (544)
  • D.6.3. Alias szablonu std::ratio_subtract (545)
  • D.6.4. Alias szablonu std::ratio_multiply (545)
  • D.6.5. Alias szablonu std::ratio_divide (546)
  • D.6.6. Szablon klasy std::ratio_equal (547)
  • D.6.7. Szablon klasy std::ratio_not_equal (547)
  • D.6.8. Szablon klasy std::ratio_less (547)
  • D.6.9. Szablon klasy std::ratio_greater (548)
  • D.6.10. Szablon klasy std::ratio_less_equal (548)
  • D.6.11. Szablon klasy std::ratio_greater_equal (548)
• D.7. Nagłówek <thread> (549)
  
  • D.7.1. Klasa std::thread (549)
  • D.7.2. Przestrzeń nazw std::this_thread (558)

Materiały dodatkowe (561)

Skorowidz (563)

• Titel: Język C++ i przetwarzanie współbieżne w akcji
• Autor: Anthony Williams
• Originaler Titel: C++ Concurrency in Action: Practical Multithreading
• Übersetzung: Mikołaj Szczepaniak
• ISBN: 978-83-246-7140-3, 9788324671403
• Veröffentlichungsdatum: 2013-06-07
• Format: E-book
• Artikelkennung: jcpppw
• Verleger: Helion