Bedingungsvariablen versus Tasks zur Synchronisation von Threads

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

Synchronisation von Threads

Zur leichteren Übersicht, erst Mal die Fakten. Die Tabelle stellt die Bedingungsvariablen den Tasks in der Form von Promise und Futures gegenüber.

Der Vorteil einer Bedingungsvariable gegenüber einem Promise und Future  Paar ist es, dass mit ihm mehrmalige Synchronisationen möglich ist. Hingegen kann ein Promise seine Benachrichtigung nur einmalig in den gemeinsamen Datenkanal schieben. Daher müssen eventuell mehrere Promise und Future Paare verwendet werden, um die Funktionalität einer Bedingungsvariable darzustellen. Wird eine Bedingungsvariable nur einmal verwendet, dann ist sie deutlich schwieriger richtig zu benutzen als ein Promise und Future Paar. So benötigen die beiden keine gemeinsame Variable und daher keine Locks, sie sind nicht anfällig für spurious wakeups oder lost wakeups. Darüber hinaus können sie mit Ausnahmen umgehen. Es spricht sehr viel dafür, Tasks Bedingungsvariablen vorzuziehen.

Wie schaut die Synchronisation mit Tasks aus?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#include <future>
#include <iostream>
#include <utility>


void doTheWork(){
  std::cout << "Processing shared data." << std::endl;
}

void waitingForWork(std::future<void>&& fut){

    std::cout << "Worker: Waiting for work." << std::endl;
    fut.wait();
    doTheWork();
    std::cout << "Work done." << std::endl;

}

void setDataReady(std::promise<void>&& prom){

    std::cout << "Sender: Data is ready."  << std::endl;
    prom.set_value();

}

int main(){

  std::cout << std::endl;

  std::promise<void> sendReady;
  auto fut= sendReady.get_future();

  std::thread t1(waitingForWork,std::move(fut));
  std::thread t2(setDataReady,std::move(sendReady));

  t1.join();
  t2.join();

  std::cout << std::endl;
  
}

Relativ unspektakulär.

Mit Hilfe des Promise sendReady (Zeile 30) wird der Future fut (Zeile 32) erzeugt. In diesem Fall signalisiert der Promise durch seinen Rückgabewert void in std::promise<void> sendReady, dass er nur eine Benachrichtigung schickt. Beide Kommunikationsendpunkte werden in den Thread t1 bzw. t2 (Zeile 33 und 34) verschoben. Nun wartet der Future mit seinem Aufruf fut.wait() (Zeile 13) darauf, dass ihm der Promise mit prom.set_value() (Zeile 22) seine Benachrichtigung schickt.

Sowohl die Struktur des Programms als auch die Ausgabe des Programms entspricht dem Beispielprogramm des Artikels Bedingungsvariablen.

Wie geht's weiter?

Auf die Suche in die Breite kommt die Suche in die Tiefe. Diesem Motto folgend, geht es in den nächsten Artikeln um das C++-Speichermodell. Auch wenn die wenigsten Entwickler jemals die Feature des C++-Speichermodells einsetzen werden, wollen und sollten, so hilft das C++-Speichermodell doch, ein tieferes Verständnis für die Herausforderung des Multithreading Programmierung zu entwickeln. 

Hintergrundinformation

std::promise   

    Die Details lassen sich schön auf cppreference nachlesen.

std::future   

    Die Details lassen sich schön auf cppreference nachlesen.

 

 

 

 

 

 

 

 

 

 

Go to Leanpub/cpplibrary "What every professional C++ programmer should know about the C++ standard library".   Hole dir dein E-Book. Unterstütze meinen Blog.