Variabili condivise in C++ 11

Question

Così ho preso una classe OS lo scorso semestre e abbiamo avuto un progetto di concorrenza/threading. Era un sim dell'aeroporto che atterrò degli aerei/li fece decollare nella direzione che soffiava il vento. Dovevamo farlo in Java. Così ora che le finali sono finite e sono annoiato, sto provando a farlo in C++ 11. In Java ho usato una variabile sincronizzata per il wind (0 - 360) in main e l'ho passata ai 3 thread che stavo usando. La mia domanda è: puoi farlo in C++ 11? È un lettore/scrittore di base, un thread scrive/aggiorna il vento, l'altro 2 (decollo/terra) letto.

Ho funzionato avendo una variabile del vento globale nel mio file di implementazione "threads.cpp". Ma c'è un modo per passare una variabile a tutti i thread che voglio e tutti li tengono d'occhio? O è meglio per me usare semplicemente la variabile globale e non passare nulla? (Perché/perché no?) Stavo guardando std::ref() ma non ha funzionato.

MODIFICA: Sto già utilizzando mutex e lock_guard. Sto solo cercando di capire come passare e mantenere una variabile aggiornata in tutti i thread. In questo momento si aggiorna solo nel thread di scrittura.

Answer 1

È possibile utilizzare un std::mutex con std::lock_guard per sincronizzare l'accesso ai dati condivisi. O se i dati condivisi rientrano in un numero intero, è possibile utilizzare std::atomic<int> senza bloccare.

Se si desidera evitare le variabili globali, passare semplicemente l'indirizzo dello stato condiviso alle funzioni del thread al momento dell'avvio. Per esempio:

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

Si potrebbe voler creare per esempio, l'oggetto del vento, sul mucchio con new attraverso un std::shared_ptr. Passa questo puntatore a tutti i thread interessati e usa uno std::mutex e std::lock_guard per cambiarlo.

Answer 3

L'utilizzo di std::mutex e std::lock_guard simula ciò che fa una variabile sincronizzata Java (solo in Java ciò avviene in segreto senza che tu lo sappia, in C++ lo fai esplicitamente).

Tuttavia, avendo un produttore (c'è solo una direzione di vento) e comunque solo i consumatori, è sufficiente scrivere in un esempio std::atomic<int> variabile con ordine rilassato, e da leggere da quella variabile da ciascun consumatore, sempre con un ordine rilassato. A meno che tu non abbia la necessità che la visione globale di tutti gli aeroplani sia coerente (ma poi dovresti eseguire una simulazione a serrature, che rende il threading senza senso), non c'è bisogno di sincronizzazione, devi solo assicurarti che ogni valore che le letture dell'aeroplano in qualsiasi momento sono corrette e non possono verificarsi risultati intermedi alterati. In altre parole, hai bisogno di un aggiornamento atomico.
L'ordine di memoria rilassato è sufficiente, poiché se tutto ciò che leggi è un valore, non è necessario che avvenga prima delle garanzie.

Un aggiornamento atomico (o meglio, una scrittura atomica) è almeno un ordine di grandezza, se non di più, più veloce. Le letture e le scritture atomiche con ordinamento rilassato sono in effetti semplici normali letture e scritture su molte (la maggior parte) architetture mainstream.

La variabile non deve essere globale, puoi anche tenerla nell'oscilloscopio del ciclo di simultion del thread principale e passare un riferimento (o un puntatore) ai thread.