Szczegóły ebooka

Język C++ i przetwarzanie współbieżne w akcji. Wydanie II

Język C++ i przetwarzanie współbieżne w akcji. Wydanie II

Anthony Williams

Ebook

Jeśli aplikacja ma działać szybko i niezawodnie, najlepiej wybrać C++, dojrzały i wszechstronny język programowania, konsekwentnie rozwijany przez mistrzów kodowania. Wymaga on zachowania pewnej dyscypliny podczas pracy, jednak pozwala na uzyskanie kodu o znakomitej wydajności. Nowy standard C++17 zapewnia doskonałą obsługę wielowątkowości oraz programowania wieloprocesorowego wymaganego podczas szybkiego przetwarzania grafiki, uczenia maszynowego czy też wykonywania innych zadań, w których kluczową sprawą okazuje się wydajność.

Ta książka jest drugim, zaktualizowanym i uzupełnionym wydaniem doskonałego podręcznika dla profesjonalistów. Szczegółowo opisano w niej wszystkie etapy programowania współbieżnego: od utworzenia wątków po projektowanie wielowątkowych algorytmów i struktur danych. Przedstawiono zastosowania klas std::thread i std::mutex oraz funkcji std::async, a także złożone zagadnienia związane z operacjami atomowymi i modelem pamięci. Sporo miejsca poświęcono diagnozowaniu kodu i analizie rodzajów błędów. Opisano techniki lokalizowania błędów oraz metody testowania kodu. Prezentowany materiał został uzupełniony przykładami kodu i praktycznymi ćwiczeniami. Znalazły się tu również porady i wskazówki, które docenią wszyscy programiści C++.

W tej książce między innymi:

  • nowości w standardzie C++17
  • zagadnienia niskiego poziomu: model pamięci i operacje atomowe
  • zagadnienia wyższego poziomu: złożone struktury danych
  • zagadnienia wysokiego poziomu: kod wielowątkowy i zarządzanie wątkami
  • obsługa równoległości za pomocą funkcji dodanych w standardzie C++17
  • debugowanie kodu wielowątkowego

Programuj elegancko, twórz wydajny i czysty kod. Oto współbieżność w C++!

  • Słowo wstępne (11)
  • Podziękowania (13)
  • O tej książce (15)
  • O autorze (19)

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

  • 1.1. Czym jest współbieżność? (22)
    • 1.1.1. Współbieżność w systemach komputerowych (22)
    • 1.1.2. Modele współbieżności (25)
    • 1.1.3. Współbieżność kontra równoległość (27)
  • 1.2. Dlaczego warto stosować współbieżność? (27)
    • 1.2.1. Stosowanie współbieżności do podziału zagadnień (27)
    • 1.2.2. Stosowanie współbieżności do podniesienia wydajności - równoległość zadań i danych (28)
    • 1.2.3. Kiedy nie należy stosować współbieżności (30)
  • 1.3. Współbieżność i wielowątkowość w języku C++ (31)
    • 1.3.1. Historia przetwarzania wielowątkowego w języku C++ (31)
    • 1.3.2. Obsługa współbieżności w nowym standardzie (32)
    • 1.3.3. Większa obsługa współbieżności i równoległości w standardach C++14 i C++17 (33)
    • 1.3.4. Efektywność biblioteki wątków języka C++ (33)
    • 1.3.5. Mechanizmy związane z poszczególnymi platformami (34)
  • 1.4. Do dzieła (35)
    • 1.4.1. Witaj, świecie współbieżności! (35)
  • 1.5. Podsumowanie (36)

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

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

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

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

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

  • 4.1. Oczekiwanie na zdarzenie lub inny warunek (102)
    • 4.1.1. Oczekiwanie na spełnienie warunku za pomocą zmiennych warunkowych (103)
    • 4.1.2. Budowa kolejki gwarantującej bezpieczne przetwarzanie wielowątkowe przy użyciu zmiennych warunkowych (106)
  • 4.2. Oczekiwanie na jednorazowe zdarzenia za pomocą przyszłości (111)
    • 4.2.1. Zwracanie wartości przez zadania wykonywane w tle (112)
    • 4.2.2. Wiązanie zadania z przyszłością (114)
    • 4.2.3. Obietnice (szablon std::promise) (117)
    • 4.2.4. Zapisywanie wyjątku na potrzeby przyszłości (119)
    • 4.2.5. Oczekiwanie na wiele wątków (121)
  • 4.3. Oczekiwanie z limitem czasowym (124)
    • 4.3.1. Zegary (124)
    • 4.3.2. Okresy (125)
    • 4.3.3. Punkty w czasie (127)
    • 4.3.4. Funkcje otrzymujące limity czasowe (129)
  • 4.4. Upraszczanie kodu za pomocą technik synchronizowania operacji (131)
    • 4.4.1. Programowanie funkcyjne przy użyciu przyszłości (131)
    • 4.4.2. Synchronizacja operacji za pomocą przesyłania komunikatów (136)
    • 4.4.3. Współbieżność w stylu kontynuacji dzięki użyciu Concurrency TS (141)
    • 4.4.4. Łączenie kontynuacji ze sobą (143)
    • 4.4.5. Oczekiwanie na więcej niż tylko jedną przyszłość (146)
    • 4.4.6. Oczekiwanie za pomocą when_any na pierwszą przyszłość w zbiorze (148)
    • 4.4.7. Zasuwy i bariery w Concurrency TS (151)
    • 4.4.8. Zasuwa typu podstawowego - std::experimental::latch (151)
    • 4.4.9. Podstawowa bariera - std::experimental::barrier (153)
    • 4.4.10. std::experimental::flex_barrier, czyli elastyczniejszy przyjaciel std::experimental:barrier (155)
  • 4.5. Podsumowanie (156)

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

  • 5.1. Podstawowe elementy modelu pamięci (158)
    • 5.1.1. Obiekty i miejsca w pamięci (158)
    • 5.1.2. Obiekty, miejsca w pamięci i przetwarzanie współbieżne (159)
    • 5.1.3. Kolejność modyfikacji (161)
  • 5.2. Operacje i typy atomowe języka C++ (161)
    • 5.2.1. Standardowe typy atomowe (162)
    • 5.2.2. Operacje na typie std::atomic_flag (165)
    • 5.2.3. Operacje na typie std::atomic (167)
    • 5.2.4. Operacje na typie std::atomic - arytmetyka wskaźników (170)
    • 5.2.5. Operacje na standardowych atomowych typach całkowitoliczbowych (172)
    • 5.2.6. Główny szablon klasy std::atomic<> (172)
    • 5.2.7. Wolne funkcje dla operacji atomowych (174)
  • 5.3. Synchronizacja operacji i wymuszanie ich porządku (176)
    • 5.3.1. Relacja synchronizacji (178)
    • 5.3.2. Relacja poprzedzania (179)
    • 5.3.3. Porządkowanie pamięci na potrzeby operacji atomowych (181)
    • 5.3.4. Sekwencje zwalniania i relacja synchronizacji (201)
    • 5.3.5. Ogrodzenia (204)
    • 5.3.6. Porządkowanie operacji nieatomowych za pomocą operacji atomowych (206)
    • 5.3.7. Porządkowanie operacji nieatomowych (207)
  • 5.4. Podsumowanie (210)

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

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

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

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

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

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

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

  • 9.1. Pule wątków (356)
    • 9.1.1. Najprostsza możliwa pula wątków (356)
    • 9.1.2. Oczekiwanie na zadania wysyłane do puli wątków (359)
    • 9.1.3. Zadania oczekujące na inne zadania (363)
    • 9.1.4. Unikanie współzawodnictwa w dostępie do kolejki zadań (366)
    • 9.1.5. Wykradanie zadań (368)
  • 9.2. Przerywanie wykonywania wątków (372)
    • 9.2.1. Uruchamianie i przerywanie innego wątku (373)
    • 9.2.2. Wykrywanie przerwania wątku (375)
    • 9.2.3. Przerywanie oczekiwania na zmienną warunkową (375)
    • 9.2.4. Przerywanie oczekiwania na zmienną typu std::condition_variable_any (379)
    • 9.2.5. Przerywanie pozostałych wywołań blokujących (381)
    • 9.2.6. Obsługa przerwań (382)
    • 9.2.7. Przerywanie zadań wykonywanych w tle podczas zamykania aplikacji (383)
  • 9.3. Podsumowanie (384)

Rozdział 10. Algorytmy równoległości (385)

  • 10.1. Algorytmy równoległe w bibliotece standardowej (385)
  • 10.2. Polityki wykonywania (386)
    • 10.2.1. Ogólny efekt wyboru polityki wykonywania (386)
    • 10.2.2. std::execution::sequenced_policy (388)
    • 10.2.3. std::execution::parallel_policy (388)
    • 10.2.4. std::execution::parallel_unsequenced_policy (389)
  • 10.3. Algorytmy równoległości w bibliotece standardowej C++ (390)
    • 10.3.1. Przykłady używania algorytmów równoległych (392)
    • 10.3.2. Licznik odwiedzin (394)
  • 10.4. Podsumowanie (396)

Rozdział 11. Testowanie i debugowanie aplikacji wielowątkowych (397)

  • 11.1. Rodzaje błędów związanych z przetwarzaniem współbieżnym (398)
    • 11.1.1. Niechciane blokowanie (398)
    • 11.1.2. Sytuacje wyścigu (399)
  • 11.2. Techniki lokalizacji błędów związanych z przetwarzaniem współbieżnym (400)
    • 11.2.1. Przeglądanie kodu w celu znalezienia ewentualnych błędów (401)
    • 11.2.2. Znajdowanie błędów związanych z przetwarzaniem współbieżnym poprzez testowanie kodu (403)
    • 11.2.3. Projektowanie kodu pod kątem łatwości testowania (405)
    • 11.2.4. Techniki testowania wielowątkowego kodu (407)
    • 11.2.5. Projektowanie struktury wielowątkowego kodu testowego (410)
    • 11.2.6. Testowanie wydajności wielowątkowego kodu (413)
  • 11.3. Podsumowanie (414)

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

  • A.1. Referencje do r-wartości (415)
  • A.2. Usunięte funkcje (420)
  • A.3. Funkcje domyślne (421)
  • A.4. Funkcje constexpr (425)
  • A.5. Funkcje lambda (430)
  • A.6. Szablony zmiennoargumentowe (436)
  • A.7. Automatyczne określanie typu zmiennej (440)
  • A.8. Zmienne lokalne wątków (441)
  • A.9. Ustalanie argumentu szablonu klasy (442)
  • A.10. Podsumowanie (443)

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

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

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

  • D.1. Nagłówek (465)
  • D.2. Nagłówek (481)
  • D.3. Nagłówek (498)
  • D.4. Nagłówek (536)
  • D.5. Nagłówek (561)
  • D.6. Nagłówek (613)
  • D.7. Nagłówek (619)

Skorowidz (631)

  • Tytuł: Język C++ i przetwarzanie współbieżne w akcji. Wydanie II
  • Autor: Anthony Williams
  • Tytuł oryginału: C++ Concurrency in Action, 2nd Edition
  • Tłumaczenie: Robert Górczyński, Mikołaj Szczepaniak
  • ISBN: 978-83-283-4449-5, 9788328344495
  • Data wydania: 2019-12-16
  • Format: Ebook
  • Identyfikator pozycji: jcppw2
  • Wydawca: Helion