Multithreading: devo proteggere la mia variabile nel metodo di sola lettura?

Question

Ho alcune domande sull'utilizzo del blocco per proteggere la mia struttura di dati condivisa. Sto usando C/C++/objC/objC++

Per esempio ho una classe contatore che utilizzato in ambiente multi-thread

class MyCounter { 
private: 
    int counter; 
    std::mutex m; 

public: 
    int getCount() const { 
     return counter; 
    } 
    void increase() { 
     std::lock_guard<std::mutex> lk(m); 
     counter++; 
    } 
}; 

1. ho bisogno di usare std::lock_guard<std::mutex> lk(m); in getCount() metodo per farlo thread-safe?

2. Cosa succede se ci sono solo due thread: un thread di lettura e un thread di scrittura quindi devo proteggerlo del tutto? Perché c'è solo un thread sta modificando la variabile, quindi penso che nessun aggiornamento perso accadrà.

3. Se ci sono più scrittore/lettore per una variabile di tipo primitivo condiviso (ad esempio int), cosa può accadere se si blocca solo nel metodo di scrittura ma non nel metodo di lettura? Il tipo a 8 bit farà la differenza rispetto al tipo a 64 bit?

4. I tipi primitivi sono atomici per impostazione predefinita? Ad esempio, scrivere su un char è sempre atomico? (So ​​che questo è vero in Java, ma non so di C++ e sto usando il compilatore LLVM su Mac se le cose piattaforma)

Answer 1

Sì, a meno che non si può garantire che le modifiche alla variabile sottostante counter sono atomiche, hai bisogno del mutex.

esempio

classica, dire counter è un valore a due byte che è incrementato nelle fasi (non atomici):

add 1 to lower byte 
if lower byte is 0: 
    add 1 to upper byte 

e il valore iniziale è 255.

Se un altro filo viene in qualsiasi punto tra la modifica del byte inferiore e la modifica del byte superiore, leggerà 0 anziché 255 (pre-incremento) o 256 (post-incremento) corretto.

In termini di quali tipi di dati sono atomici, l'ultimo standard C++ li definisce nell'intestazione <atomic>.

Se il numero di telefono non ha ha capacità C++ 11, quindi è verso l'implementazione quali tipi sono atomici.

Answer 2

Sì, in questo caso è necessario bloccare anche la lettura.

Ci sono diverse alternative: qui un blocco è piuttosto pesante. Le operazioni atomiche sono le più ovvie (senza blocco). Esistono anche altri approcci al blocco in questo progetto: il blocco di scrittura in lettura è un esempio.

Answer 3

Sì, credo che sia necessario bloccare anche la lettura. Ma dal momento che stai usando le caratteristiche del C++ 11, perché non usi invece lo std::atomic<int> counter;?

Answer 4

Non è possibile garantire che più thread non modificano la variabile allo stesso tempo. e se si verifica una situazione di questo tipo la tua variabile sarà confusa o il programma potrebbe bloccarsi. Per evitare tali casi è sempre meglio e più sicuro rendere sicuro il thread del programma.

È possibile utilizzare i techinques sincronizzazione disponibili come: Mutex, Lock, attributo di sincronizzazione (disponibile per MS C++)