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 leichtern Übersicht, erst Mal die Fakten. Die Tabelle stellt die Bedingungsvariablen den Task in der Form von Promise und Futures gegenüber.

ConditionVariableVersusTask

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 sein 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 Artikel Bedingungsvariablen.

promiseFutureSynchronize

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.

 

 

Do you want to get the source code? Source code repository

 

Kommentare   

0 #1 Summoners War Hack 2016-05-19 05:03
I just could not go away your web site prior to suggesting
that I actually enjoyed the usual information an individual supply to your guests?

Is gonna be back frequently to check up on new posts
Zitieren

Kommentar schreiben


Rainer Grimm

Modernes C++

Neue Beiträge zum Wochenende

Beiträge-Archiv

Sourcecode

Besucher

Heute 96

Woche 290

Monat 3104

Insgesamt 55172

Aktuell sind 7 Gäste und keine Mitglieder online