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

(ebook) (audiobook) (audiobook)

Promocja Przejdź
Promocja Przejdź

Język C++ i przetwarzanie współbieżne w akcji. Wydanie II Anthony Williams - okladka książki

Język C++ i przetwarzanie współbieżne w akcji. Wydanie II Anthony Williams - audiobook MP3

Język C++ i przetwarzanie współbieżne w akcji. Wydanie II Anthony Williams - audiobook CD

Zajrzyj do książki

Autor:: Anthony Williams
Serie wydawnicze:: W Akcji
Wydawnictwo:: Helion
Wydawnictwo:: Helion
Ocena:: 4.6/6 Opinie: 10
Stron:: 640
Druk:: oprawa miękka
Dostępne formaty::      PDF

     ePub

     Mobi

Czytaj fragment

Książka

59,40 zł ~~99,00 zł~~ (-40%)

79,20 zł najniższa cena z 30 dni

Dodaj do koszyka

Realizacja zamówień od 2026-03-16

Ebook

49,50 zł ~~99,00 zł~~ (-50%)

49,50 zł najniższa cena z 30 dni

Dodaj do koszyka lub Kup na prezent Kup 1-kliknięciem

Przenieś na półkę

Do przechowalni

Powiadom o dostępności audiobooka »

Najczęściej kupowane razem

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

Opus magnum C++. Programowanie w języku C++. Wydanie III poprawione (komplet) Jerzy Grębosz

Programowanie. Teoria i praktyka w C++. Wydanie IV Bjarne Stroustrup

Cena zestawu: 290.77 zł

Oszczędzasz: 206,23 zł (41%)

Dodaj do koszyka

Najczęściej kupowane razem

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

Język C++ i przetwarzanie współbieżne w akcji Anthony Williams

Programowanie. Teoria i praktyka w C++. Wydanie IV Bjarne Stroustrup

Cena zestawu: 168.50 zł

Oszczędzasz: 168,50 zł (50%)

Dodaj do koszyka

Czego się nauczysz?

Różnic między współbieżnością a równoległością w programowaniu C++
Tworzenia i zarządzania wątkami z użyciem std::thread oraz obsługi wyjątków
Przekazywania argumentów do funkcji wątków i przenoszenia własności wątku
Synchronizowania wątków za pomocą mutexów, blokad i zmiennych warunkowych
Unikania sytuacji wyścigu, zakleszczeń oraz projektowania bezpiecznego kodu wielowątkowego
Wykorzystywania alternatywnych mechanizmów ochrony danych i blokowania rekurencyjnego
Stosowania przyszłości (std::future, std::promise) do synchronizacji zadań asynchronicznych
Zarządzania czasem i oczekiwaniem w operacjach współbieżnych (timery, limity czasowe)
Implementowania struktur danych i algorytmów współbieżnych z blokadami i bez blokad
Korzystania z typów atomowych i modelu pamięci C++ do operacji niskopoziomowych
Projektowania wydajnych struktur danych i algorytmów na potrzeby przetwarzania wielowątkowego
Wdrażania pul wątków, zarządzania zadaniami i obsługi przerywania wątków
Używania algorytmów równoległych oraz polityk wykonywania dostępnych w C++17
Testowania i debugowania aplikacji wielowątkowych oraz lokalizowania typowych błędów
Stosowania nowoczesnych funkcji języka C++11/14/17 przydatnych w programowaniu współbieżnym
Tworzenia kompletnych systemów komunikacji między wątkami na przykładzie aplikacji bankomatu

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++!

Wybrane bestsellery

O autorze książki

Anthony Williams od ponad dwudziestu lat programuje w C++, a także udziela porad i szkoli w tym zakresie. Od 2001 roku jest aktywnym członkiem organizacji BSI C++ Standards Panel. Brał udział w opracowywaniu i implementacji standardów C++. Kontynuuje prace nad rozszerzaniem pakietu współbieżności w tym języku.

Zobacz pozostałe książki z serii W Akcji

Ebooka "Język C++ i przetwarzanie współbieżne w akcji. Wydanie II" przeczytasz na:

czytnikach Inkbook, Kindle, Pocketbook, Onyx Booxs i innych
systemach Windows, MacOS i innych

systemach Windows, Android, iOS, HarmonyOS
na dowolnych urządzeniach i aplikacjach obsługujących formaty: PDF, EPub, Mobi

Masz pytania? Zajrzyj do zakładki Pomoc »

Oceny i opinie klientów: Język C++ i przetwarzanie współbieżne w akcji. Wydanie II Anthony Williams

(10)

6
(3)
5
(3)
4
(3)
3
(0)
2
(0)
1
(1)

4.6

Szczegóły książki

Dane producenta: »
Tytuł oryginału:: C++ Concurrency in Action, 2nd Edition
Tłumaczenie:: Robert Górczyński, Mikołaj Szczepaniak
ISBN Książki drukowanej:: 978-83-283-4448-8, 9788328344488
Data wydania książki drukowanej :: 2019-12-16
ISBN Ebooka:: 978-83-283-4449-5, 9788328344495
Data wydania ebooka :: 2019-12-16 Data wydania ebooka często jest dniem wprowadzenia tytułu do sprzedaży i może nie być równoznaczna z datą wydania książki papierowej. Dodatkowe informacje możesz znaleźć w darmowym fragmencie. Jeśli masz wątpliwości skontaktuj się z nami sklep@helion.pl.
Format:: 168x237
Numer z katalogu:: 96566
Rozmiar pliku Pdf:: 5.4MB
Rozmiar pliku ePub:: 4.5MB
Rozmiar pliku Mobi:: 11.8MB
Pobierz przykładowy rozdział PDF
Przykłady na ftp

Erraty / Zgłoś erratę
Kategorie:
Programowanie » C++ - Programowanie
Serie wydawnicze: W Akcji

Dostępność produktu

Produkt nie został jeszcze oceniony pod kątem ułatwień dostępu lub nie podano żadnych informacji o ułatwieniach dostępu lub są one niewystarczające. Prawdopodobnie Wydawca/Dostawca jeszcze nie umożliwił dokonania walidacji produktu lub nie przekazał odpowiednich informacji na temat jego dostępności.

Spis treści książki

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)

pokaż cały spis treści

Helion - inne książki

Najczęściej zadawane pytania (FAQ)

1. Jakie zagadnienia dotyczące C++ i programowania współbieżnego są omawiane w tej książce?

Książka szczegółowo opisuje programowanie współbieżne w C++, m.in. zarządzanie wątkami, synchronizację, projektowanie struktur danych z blokadami i bez blokad, model pamięci, algorytmy równoległe oraz testowanie i debugowanie kodu wielowątkowego. Uwzględnia nowości ze standardu C++17.

2. Czy książka zawiera przykłady kodu i praktyczne ćwiczenia?

Tak, publikacja zawiera liczne przykłady kodu oraz praktyczne ćwiczenia, które pomagają zrozumieć i utrwalić omawiane zagadnienia dotyczące programowania współbieżnego w C++.

3. Czy znajdę tu informacje o najnowszych standardach języka C++?

Tak, książka omawia nowości wprowadzone w standardzie C++17, w tym obsługę wielowątkowości, nowe funkcje oraz narzędzia ułatwiające programowanie współbieżne i równoległe.

4. Czy publikacja nadaje się do samodzielnej nauki?

Tak, książka jest napisana w sposób przystępny i uporządkowany, co umożliwia samodzielną naukę, zarówno osobom chcącym odświeżyć wiedzę, jak i tym, które chcą rozwinąć umiejętności w zakresie współbieżności w C++.

5. Jakie konkretne narzędzia i biblioteki C++ są omawiane w książce?

W książce opisano m.in. klasy std::thread, std::mutex, std::async, std::promise, std::atomic, a także funkcje i narzędzia z biblioteki standardowej C++ dotyczące wielowątkowości i synchronizacji.

6. Czy książka porusza temat debugowania i testowania kodu wielowątkowego?

Tak, jeden z rozdziałów poświęcono w całości rodzajom błędów specyficznych dla programowania współbieżnego oraz technikom ich wykrywania, testowania i debugowania.

7. W jakiej formie dostępna jest książka na Helion.pl?

Książka jest dostępna w wersji drukowanej oraz jako e-book (PDF, ePub, mobi), co pozwala na wygodne czytanie na różnych urządzeniach.

8. Czy książka może być pomocna przy rozwiązywaniu problemów wydajnościowych w aplikacjach C++?

Tak, publikacja zawiera liczne porady i wskazówki dotyczące optymalizacji wydajności kodu współbieżnego oraz unikania typowych pułapek związanych z wielowątkowością.