Inhaltsverzeichnis[Anzeigen]

Modernes C++: Concurrency meistern

conSmall

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/

Abonniere den Newsletter (+ pdf Päckchen)

Beiträge-Archiv

Sourcecode

Neuste Kommentare