Come creare buffer di sicurezza thread-safe/POD?

Question

Il mio problema è abbastanza comune, suppongo, ma mi fa impazzire:

Ho un'applicazione multi-thread con 5 thread. 4 di questi fili fanno il loro lavoro, come le comunicazioni di rete e di accesso file system locale, e quindi tutti scrivono loro uscita ad una struttura di dati di questa forma:

struct Buffer { 
    std::vector<std::string> lines; 
    bool has_been_modified; 
} 

The 5th stampe discussione questi buffer/strutture allo schermo:

Buffer buf1, buf2, buf3, buf4; 

... 

if (buf1.has_been_modified || 
    buf2.has_been_modified || 
    buf3.has_been_modified || 
    buf4.has_been_modified) 
{ 
    redraw_screen_from_buffers(); 
} 

Come proteggo i buffer vengano sovrascritti mentre sono in corso o letti o scritti a?

Non riesco a trovare una soluzione adeguata, anche se penso che questo deve essere un problema comune silenzioso.

Grazie.

Answer 1

È necessario utilizzare un mutex. La classe mutex è std::mutex. Con C++ 11 puoi usare std::lock_guard<std::mutex> per incapsulare il mutex usando RAII. Così si avrebbe cambiare il vostro Buffer struct per

struct Buffer { 
    std::vector<std::string> lines; 
    bool has_been_modified; 
    std::mutex mutex; 
}; 

e ogni volta che leggere o scrivere al buffer o has_been_modified si farebbe

std::lock_guard<std::mutex> lockGuard(Buffer.mutex); //Do this for each buffer you want to access 
... //Access buffer here 

e il mutex uscirà automaticamente dal lock_guard quando viene distrutta .

Ulteriori informazioni sui mutex here.

Answer 2

È possibile utilizzare un mutex (o mutex) attorno ai buffer per garantire che non vengano modificati da più thread contemporaneamente.

// Mutex shared between the multiple threads 
std::mutex g_BufferMutex; 

void redraw_screen_from_buffers() 
{ 
    std::lock_guard<std::mutex> bufferLockGuard(g_BufferMutex); 
    //redraw here after mutex has been locked. 
} 

Quindi il codice di modifica del buffer dovrebbe bloccare lo stesso mutex quando i buffer vengono modificati.

void updateBuffer() 
{ 
    std::lock_guard<std::mutex> bufferLockGuard(g_BufferMutex); 
    // update here after mutex has been locked 
} 

This contiene alcuni esempi di mutex.

Answer 3

Quello che sembra si vuole ottenere è avere più thread/worker e un osservatore. Quest'ultimo ha bisogno di fare il suo lavoro solo quando tutti i lavoratori sono fatti/segnale. Se questo è il caso, controllare il codice in questo SO q/a. std::condition_variable - Wait for several threads to notify observer

Answer 4

mutex sono una cosa molto carina quando si cerca di evitare dataraces, e sono sicuro che la risposta inviata da @Phantom soddisferà la maggior parte delle persone. Tuttavia, si dovrebbe sapere che questo non è scalabile per sistemi di grandi dimensioni.

Bloccando si stanno sincronizzando i fili. Poiché solo uno alla volta può accedere al vettore, la scrittura del thread nel contenitore farà attendere l'altro fino a che non finisca ... potrebbe essere un bene per te, ma provoca gravi colli di bottiglia nelle prestazioni quando sono necessarie prestazioni elevate.

La soluzione migliore sarebbe utilizzare una struttura senza blocco più complessa. Sfortunatamente non penso che ci sia una struttura lockfree nella STL.Un esempio di coda di lockfree è disponibile here

Utilizzando una tale struttura, i vostri 4 thread di lavoro sarebbero in grado di accodare i messaggi al contenitore, mentre il 5 ° li avrebbe dequeue, senza dataraces

More on lockfree datastructure can be found here !