Ich hätte nie gedacht, dass ich mit meinem letzten Artikel zum Threadsicheres Initialisieren eines Singleton soviel Emotion wecken würde. Daher will ich diesen Artikel nützen, die Emotionen zusammenzufassen.

Singletons lassen sich in vielen Variationen in C++11 threadsicher initialisieren. Dabei können vereinfachend gesprochen Zusicherung der C++-Laufzeit, Locks oder auch atomare Operationen verwendet werden. Mich interessiert vor allem in diesem Artikel die Antwort auf die Frage: Welche Performanzunterschiede bestehen zwischen den Variationen?

Der erzeugende Thread muss sich um die Lebenszeit seines erzeugten Threads (th) kümmern. Der Erzeuger wartet entweder, bis sein Kind seine Arbeit vollzogen hat (th.join()) oder er trennt sich von ihm (th.detach()). Das ist alles ein alter Hut. Dies gilt aber nicht für std:.async. Der große Charme von std::async besteht auch darin, dass sich der Erzeuger nicht um die Lebenszeit seines Kindes kümmern muss. 

Mit C++14 erhielt C++ Reader-Writer Locks. Die Idee ist einfach und überzeugend. Während beliebig viele Threads gleichzeitig lesend auf einen kritischen Bereich zugreifen dürfen, darf nur genau ein Thread auf diesen schreibend zugreifen.

Werden Promise und Future für die Synchronization von Threads verwendet, haben sie sehr viel gemein mit Bedingungsvariablen. Meist sind Tasks die bessere Wahl.

Was hat das Schlüsselwort volatile in C# und Java mit dem Schlüsselwort volatile in C++ gemein? Nichts!

Mit der Relaxed-Semantik gelten keine Synchronisations- und Ordnungsbedingungen auf den atomaren Operationen.

Mit der Acquire-Release-Semantik verlassen wir das Default-Speichermodell in C++. In der Acquire-Release-Semantik findet die Synchronisation nicht zwischen Threads, sondern zwischen atomaren Operationen auf der gleichen atomaren Variable statt.

Atomare Datentypen erlauben das Programm feingranular zu steuern und damit auch zu optimieren. Damit betreten wir aber die Domäne der Multithreading-Experten.