Gemeinsame Variablen in C++ 11

Question

So nahm ich ein OS-Klasse im letzten Semester und wir hatten ein Nebenläufigkeit/Threading-Projekt. Es war ein Flughafen-Sim, der Flugzeuge landete/in die Richtung fliegen ließ, in die der Wind wehte. Wir mussten es in Java machen. Jetzt, wo das Finale vorbei ist und mir langweilig ist, versuche ich es in C++ 11 zu tun. In Java habe ich eine synchronisierte Variable für den Wind (0 - 360) in main verwendet und an die 3 Threads übergeben, die ich benutzt habe. Meine Frage ist: Können Sie das in C++ 11 tun? Es ist ein einfacher Leser/Schreiber, ein Thread schreibt/aktualisiert den Wind, die anderen 2 (Start/Land) lesen.

Ich habe es funktioniert mit einer globalen Wind-Variable in meiner "threads.cpp" Implementierungsdatei. Aber gibt es eine Möglichkeit, eine Variable an so viele Threads zu übergeben, wie ich will und alle mithalten? Oder ist es eigentlich besser für mich, nur die globale Variable zu verwenden und nichts weiterzugeben? (Warum/warum nicht?) Ich habe mir std::ref() angesehen, aber das hat nicht funktioniert.

EDIT: Ich benutze bereits Mutex und lock_guard. Ich versuche nur herauszufinden, wie man eine Variable in allen Threads übergibt und auf dem neuesten Stand hält. Im Moment wird nur im Schreib-Thread aktualisiert.

Answer 1

Sie können einen std::mutex mit std::lock_guard verwenden, um den Zugriff auf die freigegebenen Daten zu synchronisieren. Oder wenn die geteilten Daten in eine Ganzzahl passen, können Sie std::atomic<int> ohne Sperren verwenden.

Wenn Sie globale Variablen vermeiden möchten, übergeben Sie einfach die Adresse des gemeinsamen Status an die Thread-Funktionen, wenn Sie sie starten. Zum Beispiel:

void thread_entry1(std::atomic<int>* val) {} 
void thread_entry2(std::atomic<int>* val) {} 

std::atomic<int> shared_value; 
std::thread t1(thread_entry1, &shared_value); 
std::thread t2(thread_entry2, &shared_value); 

Answer 2

Man könnte sagen, erstellen möchten, den Wind Objekt, auf dem Heap mit new durch einen std::shared_ptr. Übergeben Sie diesen Zeiger an alle interessierten Threads und verwenden Sie eine std::mutex und std::lock_guard, um es zu ändern.

Answer 3

Mit std::mutex und std::lock_guard mimicks, was eine Java-synchronisierte Variable tut (nur in Java geschieht dies heimlich ohne Sie zu wissen, in C++ machen Sie es explizit).

Jedoch ein Produzent (es gibt nur eine Richtung des Windes) und sonst nur Verbraucher, es genügt zu schreiben, um eine z. std::atomic<int> Variable mit entspannter Reihenfolge, und von dieser Variable von jedem Verbraucher zu lesen, wieder mit entspannter Reihenfolge. Wenn Sie nicht die Anforderung haben, dass die globale Ansicht aller Flugzeuge konsistent ist (aber dann müssten Sie eine Lockstep-Simulation ausführen, was das Threading sinnwidrig macht), besteht keine Notwendigkeit für eine Synchronisation, Sie müssen nur sicherstellen, dass jeder beliebige Wert vorhanden ist Flugzeug liest zu jeder Zeit ist schließlich richtig und dass keine verstümmelten Zwischenergebnisse auftreten können. Mit anderen Worten, Sie benötigen ein atomares Update.
Entspannte Speicherordnung ist auch ausreichend, denn wenn alles, was Sie lesen, ein Wert ist, brauchen Sie keine Vor-Vor-Garantien.

Ein atomares Update (oder besser: atomares Schreiben) ist mindestens eine Größenordnung, wenn nicht mehr, schneller. Atomare Lese- und Schreibvorgänge mit entspannter Reihenfolge sind in der Tat normale normale Lese- und Schreibvorgänge auf vielen (meisten) Mainstream-Architekturen.

Die Variable muss nicht global sein, Sie können sie auch im Gültigkeitsbereich der Simulationsschleife des Hauptthreads speichern und eine Referenz (oder einen Zeiger) an die Threads übergeben.