Können externe E/A-Operationen bei der Argumentation von Multithread-Programmen als seq_cst-Operationen betrachtet werde ⇐ C++

[Anonymous]

Betrachten Sie dieses Beispiel:

Code: Select all

// thread A:
start_transaction();
update_mysql();
commit_transaction();   // remove "key" from mysql tables
remove_redis_cache("key");

// thread B:
std::string msg_redis;
bool r = read_redis_cache("key",msg_redis);
if(r){
return msg_redis;
}
const std::string msg_sql = read_mysql();
update_redis_cache("key",msg_sql);

Angenommen, es sind zwischengespeicherte Daten in Redis vorhanden, bevor die Threads A und B ausgeführt werden. Kann Thread B in diesem Programm also die alten Daten von MySQL lesen und den Redis-Cache damit aktualisieren?
Das Problem besteht darin, dass Thread B die zwischengespeicherten Daten nur dann von Redis lesen kann, wenn Thread A die zwischengespeicherten Daten entfernt. Und der Entfernungsvorgang erfolgt, nachdem die Transaktion festgeschrieben wurde. Von Implementierungen her handelt es sich bei diesen Vorgängen um alle externen E/A-Vorgänge, deren Nebenwirkungen den Implementierungen unbekannt sind; Die Implementierungen wären sehr konservativ, um diese Operationen neu anzuordnen.
Stattdessen müssen wir im abstrakten Maschinensinn nur formale Überlegungen anstellen. Ich frage mich also, ob wir diese externen E/A-Operationen (sichere Multithread-Operationen) einfach als seq_cst-Operationen betrachten können, um Multithread-beobachtbares Verhalten im Sinne einer einzigen Gesamtreihenfolge zu begründen?