Synchronisierte Ausgabe-Streams mit C++20
Was passiert, wenn unsynchronisiert auf std::cout geschrieben wird? Ein vollkommenes Durcheinander. Das muss mit C++20 nicht mehr sein.
Was passiert, wenn unsynchronisiert auf std::cout geschrieben wird? Ein vollkommenes Durcheinander. Das muss mit C++20 nicht mehr sein.
![Synchronisierte Ausgabestreams mit C++20](https://heise.cloudimg.io/width/696/q85.png-lossy-85.webp-lossy-85.foil1/_www-heise-de_/imgs/18/3/0/6/0/3/4/3/TimelineCpp20-39287a6eb7f0b62c.png)
Bevor ich die synchronisierten Ausgabe-Streams in C++20 vorstelle, möchte auf die nicht synchronisierte Ausgabe in C++11 eingehen:
// coutUnsynchronized.cpp
#include <chrono>
#include <iostream>
#include <thread>
class Worker{
public:
Worker(std::string n):name(n) {};
void operator() (){
for (int i = 1; i <= 3; ++i) {
// begin work
std::this_thread::sleep_for(std::chrono::milliseconds(200)); // (3)
// end work
std::cout << name << ": " << "Work " << i << " done !!!" << '\n'; // (4)
}
}
private:
std::string name;
};
int main() {
std::cout << '\n';
std::cout << "Boss: Let's start working.\n\n";
std::thread herb= std::thread(Worker("Herb")); // (1)
std::thread andrei= std::thread(Worker(" Andrei"));
std::thread scott= std::thread(Worker(" Scott"));
std::thread bjarne= std::thread(Worker(" Bjarne"));
std::thread bart= std::thread(Worker(" Bart"));
std::thread jenne= std::thread(Worker(" Jenne")); // (2)
herb.join();
andrei.join();
scott.join();
bjarne.join();
bart.join();
jenne.join();
std::cout << "\n" << "Boss: Let's go home." << '\n'; // (5)
std::cout << '\n';
}
Der Boss beschäftigt sechs Arbeiter (Zeile 1 bis 2). Jeder Arbeiter muss drei Arbeitspakete erledigen, die jeweils eine 1/5 Sekunde benötigen (Zeile 3). Nachdem ein Arbeiter mit einem Arbeitspaket fertig ist, schreit er seinen Namen laut heraus (Zeile 4). Wenn der Boss alle Benachrichtigungen von allen Arbeitern erhalten hat, schickt er seine Truppe (Zeile 5) nach Hause. Was für ein Durcheinander für solch einen einfachen Arbeitsablauf! Jeder Arbeiter schreit seine Nachricht heraus und ignoriert dabei seine Kollegen.
![Synchronisierte Ausgabestreams mit C++20](https://heise.cloudimg.io/width/629/q85.png-lossy-85.webp-lossy-85.foil1/_www-heise-de_/imgs/18/3/0/6/0/3/4/3/coutUnsynchronized-c3c872cce6a7e7cd.png)
std::cout
ist Thread-sicher: Der C++11-Standard garantiert, dass dustd::cout
nicht schützen musst. Jeder Buchstaben wird atomar geschrieben. Mehrere Ausgabeoperationen wie im Beispiel können sich natürlich vermischen. Dieses Vermischen ist aber nur ein optisches Problem: Das Programm ist wohl definiert. Diese Aussage gilt für die globalen Stream-Objekte. Das Einfügen oder die Entnahme von den globalen Stream-Objekten (std::cout
,std::cin
,std::cerr
undstd::clog
) ist Thread-sicher. Fomaler ausgedrückt: Schreiben aufstd::cout
stellt kein Data Race, sondern eine Race Condition dar. In meinem Artikel "Race Conditions versus Data Races [1]" gehe ich genauer auf die beiden Begriffe ein.
Wie lässt sich das Problem beseitigen? Mit C++11 ist die Antwort einfach: Setze einen Lock wie std::lock_guard
ein, um synchronisiert auf std::cout
zu schreiben. Mehr Informationen zu Lock in C++11 bietet mein Artikel "Locks statt Mutexe [2]".
// coutSynchronized.cpp
#include <chrono>
#include <iostream>
#include <mutex>
#include <thread>
std::mutex coutMutex; // (1)
class Worker{
public:
Worker(std::string n):name(n) {};
void operator() (){
for (int i = 1; i <= 3; ++i) {
// begin work
std::this_thread::sleep_for(std::chrono::milliseconds(200));
// end work
std::lock_guard<std::mutex> coutLock(coutMutex); // (2)
std::cout << name << ": " << "Work " << i << " done !!!" << '\n';
} // (3)
}
private:
std::string name;
};
int main() {
std::cout << '\n';
std::cout << "Boss: Let's start working." << "\n\n";
std::thread herb= std::thread(Worker("Herb"));
std::thread andrei= std::thread(Worker(" Andrei"));
std::thread scott= std::thread(Worker(" Scott"));
std::thread bjarne= std::thread(Worker(" Bjarne"));
std::thread bart= std::thread(Worker(" Bart"));
std::thread jenne= std::thread(Worker(" Jenne"));
herb.join();
andrei.join();
scott.join();
bjarne.join();
bart.join();
jenne.join();
std::cout << "\n" << "Boss: Let's go home." << '\n';
std::cout << '\n';
}
Der coutMutex
in Zeile 1 schützt das geteilte Objekt std::cout
. Indem der coutMutex
in einen std::lock_guard
gesteckt wird, ist sichergestellt, dass der Mutex im Konstruktor (Zeile 2) gelockt und im Destruktor (Zeile 3) des std::lock_guard
freigegeben wird. Dank des coutMutex
, den coutLock
verwaltet, löst sich das vollkommene Durcheinander in Harmonie auf.
![Synchronisierte Ausgabestreams mit C++20](https://heise.cloudimg.io/width/514/q85.png-lossy-85.webp-lossy-85.foil1/_www-heise-de_/imgs/18/3/0/6/0/3/4/3/coutSynchronized-0fe4aa5fba222527.png)
Mit C++20 wird das synchronisierte Schreiben auf std::cout
zum Kinderspiel. std::basic_syncbuf
ist ein Wrapper für std::basic_streambuf
. Dieser Wrapper häuft seine Ausgabe in einem Puffer an und schreibt seinen Inhalt, wenn er destruiert wird. Konsequenterweise erscheint der Inhalt als kontinuierliche Sequenz von Buchstaben, sodass kein Durcheinander mehr möglich ist.
Dank std::basic_osyncstream
ist es möglich, direkt synchronisiert auf std::cout
zu schreiben, indem ein synchronisierter Ausgabestream zum Einsatz kommt.
Das folgende Programm basiert auf dem vorherigen Programm coutUnsynchronized.cpp
. Zum jetzigen Zeitpunkt unterstützt lediglich GCC 11 synchronisierte Ausgabe-Streams:
// synchronizedOutput.cpp
#include <chrono>
#include <iostream>
#include <syncstream>
#include <thread>
class Worker{
public:
Worker(std::string n): name(n) {};
void operator() (){
for (int i = 1; i <= 3; ++i) {
// begin work
std::this_thread::sleep_for(std::chrono::milliseconds(200));
// end work
std::osyncstream syncStream(std::cout); // (1)
syncStream << name << ": " << "Work " << i // (3)
<< " done !!!" << '\n';
} // (2)
}
private:
std::string name;
};
int main() {
std::cout << '\n';
std::cout << "Boss: Let's start working.\n\n";
std::thread herb= std::thread(Worker("Herb"));
std::thread andrei= std::thread(Worker(" Andrei"));
std::thread scott= std::thread(Worker(" Scott"));
std::thread bjarne= std::thread(Worker(" Bjarne"));
std::thread bart= std::thread(Worker(" Bart"));
std::thread jenne= std::thread(Worker(" Jenne"));
herb.join();
andrei.join();
scott.join();
bjarne.join();
bart.join();
jenne.join();
std::cout << "\n" << "Boss: Let's go home." << '\n';
std::cout << '\n';
}
Der einzige Unterschied zum vorherigen Programm coutUnsynchronized.cpp
ist, dass std::cout
in einem std::osyncstream
(Zeile 1) enthalten ist. Wenn der std::osyncstream
seinen Gültigkeitsbereich in Zeile (2) verlässt, werden seine Buchstaben übertragen und std::cout
wird geleert. Ich möchte betonen, dass der Aufruf von std::cout
im main
-Program kein Data Race darstellt und damit nicht synchronisiert werden muss. Die Ausgaben finden vor oder nach der Ausgabe der Threads statt.
Da ich den syncStream
(Zeile 3) nur einmal verwende, ist ein temporäres Objekt in diesem Fall angebrachter. Das folgende Codebeispiel stellt den angepassten Aufruf-Operator vor:
void operator()() {
for (int i = 1; i <= 3; ++i) {
// begin work
std::this_thread::sleep_for(std::chrono::milliseconds(200));
// end work
std::osyncstream(std::cout) << name << ": " << "Work " << i << " done !!!"
<< '\n';
}
}
std::basic_osyncstream syncStream
bietet zwei interessante Methoden an:
syncStream.emit()
gibt die gepufferte Ausgabe aus.syncStream.get_wrapped()
gibt einen Zeiger auf den gewrappten Puffer zurück.
cppreference.com [3] zeigt, wie sich die Ausgabe verschiedener Ausgabe-Streams mit der get_wrapped
-Methode sequenzieren lassen:
// sequenceOutput.cpp
#include <syncstream>
#include <iostream>
int main() {
std::osyncstream bout1(std::cout);
bout1 << "Hello, ";
{
std::osyncstream(bout1.get_wrapped()) << "Goodbye, " << "Planet!" << '\n';
} // emits the contents of the temporary buffer
bout1 << "World!" << '\n';
} // emits the contents of bout1
![Synchronisierte Ausgabestreams mit C++20](https://heise.cloudimg.io/width/196/q85.png-lossy-85.webp-lossy-85.foil1/_www-heise-de_/imgs/18/3/0/6/0/3/4/3/sequenceOutput-f61ba39be2296f15.png)
Wie geht's weiter?
Jetzt habe ich es vollbracht und C++20 in mehr als 70 Artikeln vollständig vorgestellt. Mehr Informationen zu C++ 20 gibt es nin meinem Buch: C++20: Get the Details [4].
Es gibt aber ein Feature, auf das ich nochmals genauer eingehen will: Coroutinen. In meinen nächsten Artikel werde ich mich mit den Schlüsselworten co_return
, co_yield
und co_await
rein spielerisch beschäftigen.
( [5])
URL dieses Artikels:
https://www.heise.de/-5061013
Links in diesem Artikel:
[1] https://www.heise.de/developer/artikel/Race-Conditions-versus-Data-Races-3717884.html
[2] https://www.grimm-jaud.de/index.php/blog/verklemmungen-loesen
[3] https://en.cppreference.com/w/cpp/io/basic_osyncstream/get_wrapped
[4] https://leanpub.com/c20
[5] mailto:rainer@grimm-jaud.de
Copyright © 2021 Heise Medien