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

Relaxed-Semantik

Bei der Relaxed-Semantik reduzieren sich die atomaren Operationen auf ihre Atomizität.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <atomic>
#include <iostream>
#include <thread>

std::atomic<int> x{0};
std::atomic<int> y{0};

void writing(){  
  x.store(2000,std::memory_order_relaxed);  
  y.store(11,std::memory_order_relaxed);
}

void reading(){  
  std::cout << y.load(std::memory_order_relaxed) << " ";  
  std::cout << x.load(std::memory_order_relaxed) << std::endl;
}

int main(){
  std::thread thread1(writing);
  std::thread thread2(reading);
  thread1.join();
  thread2.join();
};

Mit der Relaxed-Semantik ist es einfach, die entscheidenden Fragen des kleinen Programms zu beantworten. Ist das Programm wohldefiniert? Welche Werte für x und y sind möglich? Zum einen sind alle Operationen auf den Variablen x und y atomar. Somit ist das Programm wohldefiniert. Zum anderen gelten keine Einschränkungen auf den Ausführungen der beiden Threads. Es kann vorkommen, dass der thread2 die Operationen des thread1 in anderer Reihenfolge sieht. Zum ersten Mal in unserer sukzessiven Optimierung ist es zulässig, dass der Wert x == 0 und der Wert von y == 11 von dem thread2 ausgegeben wird. Somit sind alle Kombinationen der Werte von x und y möglich.

Wie geht's weiter?

Im nächsten Artikel will ich mit der Mär aufräumen, dass volatile in C++ Multithreading-Semantik besitzt.

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.