Modernes C++: Concurrency meistern

Beschreibung:

Concurrency mit modernem C++ ist eine Reise durch die bestehende und die zukünftige Nebenläufigkeit in C++.
Das Buch erklärt Ihnen die Details zu Nebenläufigkeit in modernem C++ und gibt Ihnen mehr als 100 läuffähige Programme. Damit können Sie die Theorie mit der Praxis verknüpfen um den optimalen Nutzen aus dem Buch zu ziehen.

•  C++11 und C++14 besitzen die elementaren Bausteine, um nebenläufige und parallele Programme zu schreiben.
• Mit C++17 stehen die parallelen Algorithmen der Standard Template Library (STL) vor der Tür. Das heißt, dass die meisten der Algorithmen der STL sequentiell, parallel oder vektorisiert ausgeführt werden können.
• Die Geschichte in C++ geht aber weiter. Dank C++20 können wir auf erweiterte Futures, Coroutinen, Transaktionen und noch viel mehr hoffen.

About:

• Gebundene Ausgabe: 288 Seiten
• Verlag: Hanser, (11. Juni 2018)
• Sprache: Deutsch
• ISBN-10: 3446455906
• ISBN-13: 978-3446455900

Weiterführende Informationen:

Die gibt es natürlich direkt beim Verlag.

Errata: (Heiko Eißfeldt)

• Kapitel 1.1.2
  • Geteilte Daten: s/koordiniert auf geteilten Daten zugreifen./koordiniert auf geteilte Daten zugreifen./
  • Mutex: s/kritischen Bereich, zu der die geteilte/kritischen Bereich, zu dem die geteilte/
           
• Kapitel 2.1
  
  
  • s/Um genau zu sein, gibt nicht/Um genau zu sein, gibt es nicht/
  • s/weder die Leser noch der Schreiber dieser Zeilen gehört/weder die Leser noch der Schreiber dieser Zeilen gehören/
  • s/Der zentrale Punkt des System/Der zentrale Punkt des Systems/
• Kapitel 2.1.2
  
  • s/werden wir uns mit atomare Datentypen/werden wir uns mit atomaren Datentypen/
• Kapitel 2.2.1
  
  • s/als Ergebnis eines langen Prozess/als Ergebnis eines langen Prozesses/
  • s/aber beeinflussen nicht-atomare/beeinflussen aber nicht-atomare /
• Kapitel 2.2.2
  • s/indem er die CPU zu 100% auslastet./indem er den Prozessorkern zu 100% auslastet./
  • s/von den elementaren Bausteine std::atomic_flag/von dem elementaren Baustein std::atomic_flag/
  • Bild 2.6: s/Ein Mutex, der für zwei Sekunden blockiert/Ein Mutex, der für fünf Sekunden blockiert/
• Kapitel 2.2.3
  • s/alle weiteren vollständigen oder teilweisen Spezialisierung des/alle weiteren vollständigen oder teilweisen Spezialisierungen des/
• Kapitel 2.2.5
  • s/Überblick zu alle atomaren Operationen/Überblick zu allen atomaren Operationen/
• Kapitel 2.2.6
  • s/Die freien Funktionen aber Zeiger anstelle von Referenz/Die freien Funktionen aber Zeiger anstelle von Referenzen/
• Kapitel 2.2.7
  • s/da alle Modifikation auf localPtr stattfinden/da alle Modifikationen auf localPtr stattfinden/
• Kapitel 2.3.1
  • s/Per Default für die atomaren Operationen ist/Der Default für die atomaren Operationen ist/
  • s/drei verschieden Typen/drei verschiedene Typen/
  • s/ein Ordnung zwischen Lese- und/eine Ordnung zwischen Lese- und/
• Kapitel 2.3.2
  • s/Das Bild 2.10 stellt die Reihenfolge der Operation/Das Bild 2.10 stellt die Reihenfolge der Operationen/
• Kapitel 2.3.3
  • s/Variable von den nicht-geschützt in einen geschützten Bereich/Variable von dem nicht-geschützten in einen geschützten Bereich/
  • s/dataConsumed auf true (Zeile 119) gesetzt hat/dataConsumed auf true (Zeile 19) gesetzt hat/
    .
• Kapitel 2.3.4
  • s/acquireRelease.cpp in Zeile 21 das Speichermodellstd::memory_order_acquire/acquireRelease.cpp in Zeile 23 das Speichermodell std::memory_order_acquire/
  • s/Ladeoperation in Zeile 21/Ladeoperation in Zeile 23/ (weitere Zeilenreferenzen sind um zwei zu niedrig.)
  • s/Falls das Ergebnis eine Operation a als Operation in einer Operation B verwendet wird/Falls das Ergebnis einer Operation A als Operand in einer Operation B verwendet wird/
    (drei Änderungen)
  • Nach Bild 2.19: s/ptr.store(p, std::memory_order_release ist/ptr.store(p, std::memory_order_release) ist/
  • s/dass while (!(p2 = ptr.load(std::memory_order_consume)) ein/dass while (!(p2 = ptr.load(std::memory_order_consume))) ein/
• Kapitel 2.3.5
  • s/zwischen der Inkrement-Operation in der Zeile und dem Lesen/zwischen der Inkrement-Operation in der Zeile 13 und dem Lesen/
  • s/immer die Zahl 1000 ausgibt/immer die Zahl 10000 ausgibt/
• Kapitel 2.4.1
  • s/die aus mehren load- und store-Operationen/die aus mehreren load- und store-Operationen/
  • s/StoreStore plaziert werden/StoreStore platziert werden/
• Kapitel 2.4.2
  • s/verhindert, das eine Leseoperation/verhindert, dass eine Leseoperation/
  • s/vor einem std::atomic_thread_fence( std::memory_order_release)/vor einem std::atomic_thread_fence(std::memory_order_release)/
  • s/bisherigen Grafiken verdeutlichen/folgenden Grafiken verdeutlichen/
  • s/bedeutet dies, das/bedeutet dies, dass/
• Kapitel 2.4.3
  • Bild 2.25: s/var.load(std:  :memory_order_acquire)/var.load(std::memory_order_acquire)/
  • s/Dank dem std::atomc_thread_fence/Dank dem std::atomic_thread_fence/
• Kapitel 2.2.4
  • Atomare Operationen (Zeilennummer um 2 zu niedrig)
• Kapitel 3.1.3
  • s/valSleeper in der Zeile 29/valSleeper in der Zeile 28/
  • s/Die Lebenszeit des Haupt-Threadsendet/Die Lebenszeit des Haupt-Threads endet/
• Kapitel 3.2.1
  • s/höchstens ein Thread einen Kritischer Bereich/höchstens ein Thread einen kritischen Bereich/
  • s/Der lock-Aufruf in Zeile 22/Der lock-Aufruf in Zeile 19/
  • s/ist kein Data Race, aber eine Race Conditions/ist kein Data Race, aber eine Race Condition/
  • s/Seit C++14 kennt C++ den std::shared_timed_mutex./Seit C++14 kennt C++ den Typ std::shared_timed_mutex./
  • s/geschützt werden müssen, besitzen sie beide Mutex./geschützt werden müssen, besitzen sie beide je einen Mutex./
• Kapitel 3.2.2
  • s/hingegen eine absoluten Zeitpunkt/hingegen einen absoluten Zeitpunkt.
  • s/Das Beispiel readerWriterLock.cpp setzte die Idee/Das Beispiel readerWriterLock.cpp setzt die Idee/
  • s/Ein Features eines geordneten/Ein Feature eines geordneten/
  • s/ist, nur lesend Operationen in der Funktion/ist, nur lesende Operationen in der Funktion/
• Kapitel 3.4
  • s/der Arbeit fertig ist, mit den Bedingungsvariable/der Arbeit fertig ist, mit der Bedingungsvariable/
• Kapitel 3.5
  • s/Zusätzlich zu Threads bietet C++ Tasks an um, Aufgaben/Zusätzlich zu Threads bietet C++ Tasks an, um Aufgaben/
• Kapitel 3.5.1
  • s/Der Future fragt das Ergebnis des Datenkanals ... der Berechnung./Der Future fragt das Ergebnis des Datenkanals ... der Berechnung ab./
• Kapitel 3.5.2
  • s/erforderlich, dass der Promise in separaten Thread/erforderlich, dass der Promise in einem separaten Thread/
  • s/Dies wird durch Start-Strategie/Dies wird durch die Start-Strategie/
  • s/Die Promises werde in der Reihenfolge/Die Promises werden in der Reihenfolge/
  • s/einen größeres Arbeitspaket auf mehrere Schulter zu verteilen./ein größeres Arbeitspaket auf mehrere Schultern zu verteilen./
  • s/Die return-Anweisung adddiert die Werte der Futures in Bild 3.25./Die return-Anweisung adddiert die Werte der Futures in Zeile 33./
• Kapitel 3.5.3
  • s/std::packaged_taks wird ebenfalls geren verwendet/std::packaged_task wird ebenfalls gerne verwendet/
  • s/Den Futures erzeugen/Die Futures erzeugen/
  • s/in einen neuen Thread verschoben (Zeile)/in einen neuen Thread verschoben (Zeile 55)/
• Kapitel 3.5.4
  • s/erhält die Funktion product(Zeilen 8-10), prodPromise (Zeile 33)/erhält die Funktion product(Zeilen 8-10), prodPromise (Zeile 29)/
  • s/die Instanz div der Klasse Div (Zeilen 12-18)/die Instanz div der Klasse Div (Zeilen 12-19)/
  • Tabelle 3.7: s/future.valid()/fut.valid()/
• Kapitel 3.5.5
  • s/Der Promise sendDataReady/Der Promise sendReady/
• Kapitel 4.1
  • s/gibt an, ob eine Programm/gibt an, ob ein Programm/
  • s/die parallele und vektorisierte Version (Zeile 17) auszuwählen./die parallele und vektorisierte Version (Zeile 13) auszuwählen.
  • Beispiel: s/std::paralle/std::execution/
• Kapitel 4.1.1
  • s/std::sort(std::parallel::vec/std::sort(std::execution::vec/
  • s/Zusätzlich besitzt C++17 8 neue Algorithmen/Zusätzlich besitzt C++17 8 neue Algorithmen./
• Kapitel 4.3
  • Tabelle 4.2:
    • s/std::transform_exclusive_scan    Wendet zuerst eine unäre aufrufbare Einheit auf den Bereich an und anschließend std::inclusive_scan./std::transform_exclusive_scan    Wendet zuerst eine unäre aufrufbare Einheit auf den Bereich an und anschließend std::exclusive_scan./
    • s/std::transform_exclusive_scan    Wendet zuerst eine unäre aufrufbare Einheit auf den Bereich an und anschließend std::inclusive_scan/std::transform_inclusive_scan    Wendet zuerst eine unäre aufrufbare Einheit auf den Bereich an und anschließend std::inclusive_scan./
    • std::transform_reduce    Wendet zuerst eine unäre aufrufbar Einheit auf den Bereich an und anschließend std::reduce./std::transform_reduce    Wendet zuerst eine unäre aufrufbare Einheit auf den Bereich an und anschließend std::reduce./
  • s/auf jedes Element ... zum Einsatz/auf jedem Element ... zum Einsatz/
• Kapitel 4.3.1
  • s/std::for_each_n heißt map in Haskell/std::for_each heißt map in Haskell/
  • s/für den imperative geschulten Programmierer/für den imperativ geschulten Programmierer/
   
• Kapitel 5.1.1
  • Bild 5.7 (Text ist Kopie aus Bild 5.5) std::accumulate -> std::lock_guard
  • Bild 5.8 (Text ist Kopie aus Bild 5.6) std::accumulate -> std::lock_guard
  • s/und in der Zeile 45 die Methode fetch_add/und in der Zeile 47 die Methode fetch_add/
• Kapitel 5.1.2
  • s/Die Funktion sumUp (Zeilen 20-26)/Die Funktion sumUp (Zeilen 20-27)/
  • s/in Zeile 23 kommt zum Einsatz/in Zeile 24 kommt zum Einsatz/
  • s/Jeder Thread (Zeilen 43-48) führt/Jeder Thread (Zeilen 44-50) führt/
  • s/und in den Zeilen 23 und 25/und in den Zeilen 24 und 26/
  • s/Die Zeilen 39-47 definieren die vier/Die Zeilen 40-48 definieren die vier/
  • s/Die Promises werden in den Zeilen 51-54/Die Promises werden in den Zeilen 52-62/
  • s/Die Threads führen die Funktion sumUp (Zeilen 18-25)/Die Threads führen die Funktion sumUp (Zeilen 18-26)/
  • s/Der Future fragt in Zeile 56/Der Future fragt in Zeile 64/
• Kapitel 5.2.2
  • s/Blockgültigkeit, eine std::lock_guard/Blockgültigkeit, ein std::lock_guard/
  • s/Konsistenz und eine atomaren Variable/Konsistenz und eine atomare Variable/
  • s/den Aufruf MySingleton::getInstance() in Zeile 12./den Aufruf MySingleton::getInstance() in Zeile 30./
• Kapitel 5.3.1
  • s/und den anschließend Prozess der/und den anschließenden Prozess der/
  • s/(siehe http://www.cl.cam.ac.uk/ pes20/cpp/popl085ap-sewell.pdf) nachlesen/(siehe https://www.cl.cam.ac.uk/~pes20/cpp/popl085ap-sewell.pdf) nachlesen/
  • s/betrachtet, für die die Ausführung den 1 für x ergibt./betrachtet, für die die Ausführung den Wert 1 für x ergibt./
  • s/und ein anderer Thread x (x==3) liest x ohne Synchronisation/und ein anderer Thread y = (x==3) liest x ohne Synchronisation/