Jezyk_C_i_przetwarzanie_wspolbiezne_w_akcji_Wydanie_II_jcppw2.pdf

(3371 KB) Pobierz
Tytuł oryginału: C++ Concurrency in Action, 2nd Edition
Tłumaczenie: Robert Górczyński
na podstawie: „Język C++ i przetwarzanie współbieżne w akcji”
w przekładzie Mikołaja Szczepaniaka
ISBN: 978-83-283-4448-8
Original edition copyright © 2019 by Manning Publications Co.
All rights reserved.
Polish edition copyright © 2020 by HELION SA.
All rights reserved.
All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means,
electronic or mechanical, including photocopying, recording or by any information storage retrieval system,
without permission from the Publisher.
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 Helion SA 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 Helion SA nie ponoszą również
żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce.
Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock Images LLC.
Helion SA
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/jcppw2
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Printed in Poland.
•
Kup książkę
•
Poleć książkę
•
Oceń książkę
•
Księgarnia internetowa
•
Lubię to! » Nasza społeczność
Spis treści
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++!
1.1.
21
1.2.
1.3.
1.4.
1.5.
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
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
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
Do dzieła ....................................................................................................................................... 35
1.4.1. Witaj,
świecie
współbieżności! .......................................................................................... 35
Podsumowanie .............................................................................................................................. 36
Rozdział 2. Zarządzanie wątkami
2.1.
39
2.2.
2.3.
2.4.
2.5.
2.6.
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
Przekazywanie argumentów do funkcji wątku ......................................................................... 47
Przenoszenie własności wątku .................................................................................................... 50
Wybór liczby wątków w czasie wykonywania ........................................................................... 55
Identyfikowanie wątków ............................................................................................................. 57
Podsumowanie .............................................................................................................................. 59
Kup książkę
Poleć książkę
6
Spis treści
Rozdział 3. Współdzielenie danych przez wątki
3.1.
3.2.
61
3.3.
3.4.
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
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
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
Podsumowanie ............................................................................................................................ 100
Rozdział 4. Synchronizacja współbieżnych operacji
4.1.
101
4.2.
4.3.
4.4.
4.5.
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
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
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
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
Podsumowanie ............................................................................................................................ 156
Kup książkę
Poleć książkę
Spis treści
7
Rozdział 5. Model pamięci języka C++ i operacje na typach atomowych
5.1.
157
5.2.
5.3.
5.4.
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
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<bool> ............................................................................ 167
5.2.4. Operacje na typie std::atomic<T*> — 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
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
Podsumowanie ............................................................................................................................ 210
Rozdział 6. Projektowanie współbieżnych struktur danych przy użyciu blokad
6.1.
6.2.
211
6.3.
6.4.
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
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
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
Podsumowanie ............................................................................................................................ 246
Rozdział 7. Projektowanie współbieżnych struktur danych bez blokad
7.1.
247
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
Kup książkę
Poleć książkę

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin