Ist garantiert, dass die aktualisierten Daten in MySQL für die Abfrage in einem anderen Thread sichtbar sind, wenn die B ⇐ C++

[Anonymous]

Betrachten Sie dieses Beispiel:

Code: Select all

#include 
#include 
extern char* mysql_query(MYSQL* mysql,char const*);
extern char* do_mysql_update(MYSQL* mysql);
int main(){
std::atomic flag = false;
auto t1 = std::thread([&](){
do_mysql_update(conn0);  // #1
mysql_query(conn0,"COMMIT"); // #2
flag.store(true, std::memory_order::seq_cst); // #3
});
auto t2 = std::thread([&](){
while (!flag.load(std::memory_order::relaxed)); // #4
mysql_query(conn1, "SELECT ... for shared"); // #5
});
t1.join();
t2.join();
}

Aus Sicht des C++-Standards wird #3 nicht mit #4 synchronisiert, daher gibt es keine happen-before-Beziehung zwischen #2 und #5. Das heißt, #2 und #5 sind ungeordnet, ganz zu schweigen davon, dass zwischen #2 und #5 eine globale Zeitleiste existiert. Aus dieser Perspektive ist nicht garantiert, dass #2 und #5 in der erwarteten Reihenfolge auftreten, auch wenn #2 und #5 eines der im C++-Standard definierten beobachtbaren Verhaltensweisen aufweisen. IIUC können wir beobachten, dass die von #2 und #5 erzeugten Verhaltensweisen in jeder sinnvollen Reihenfolge auftreten (auch wenn diese beiden Funktionen „Zugriffe über flüchtige GL-Werte“ beinhalten).

Das Folgende spezifiziert das beobachtbare Verhalten des Programms:

• Zugriffe über flüchtige GL-Werte werden streng nach den Regeln der abstrakten Maschine ausgewertet.
• Daten werden an die Host-Umgebung übermittelt, um in Dateien geschrieben zu werden

Die Zugriffe über flüchtige GL-Werte können in beliebiger Reihenfolge ausgewertet werden, da kein Vorheriges passiert. Ebenso können Daten in beliebiger Reihenfolge geliefert werden. Die Implementierung kann also eine Neuordnung nach der „Als-ob“-Regel durchführen, ohne beobachtbare Verhaltensweisen zu verletzen.
Ich frage mich also, dass #1 aus Sicht des C++-Standards nicht garantiert für #5 sichtbar ist. Ist dieses Verständnis richtig?