Jak utworzyć bezpieczny dla wątków bufor/POD?

Question

Mój problem jest dość powszechny Przypuszczam, ale doprowadza mnie do szału:

Mam wielowątkową aplikację z 5 wątkami. 4 z tych wątków wykonywać swoją pracę, jak komunikacji sieciowej i lokalnego dostępu do systemu plików, a następnie wszystko napisać swoje wyjście do struktury danych tego formularza:

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

5. nadrukami nić te buforowe/Konstrukcje do ekranu:

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(); 
} 

Jak chronić bufory przed zastąpieniem podczas gdy są one albo są odczytywane lub zapisywane?

Nie mogę znaleźć odpowiedniego rozwiązania, chociaż myślę, że to musi być cichy, wspólny problem.

Dzięki.

Answer 1

Powinieneś użyć muteksu. Klasa mutex to std::mutex. W C++ 11 można użyć std::lock_guard<std::mutex> do enkapsulacji muteksa za pomocą RAII. Więc można zmienić Buffer struct do

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

i kiedy odczytu lub zapisu do bufora lub has_been_modified byś zrobił

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

i mutex zostanie automatycznie zwolniony przez lock_guard gdy jest zniszczona .

Możesz przeczytać więcej o muteksach here.

Answer 2

Możesz użyć muteksu (lub muteksów) wokół buforów, aby upewnić się, że nie są one modyfikowane przez wiele wątków w tym samym czasie.

// 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. 
} 

Następnie kod modyfikacji bufora musiałby blokować ten sam muteks, gdy bufory są modyfikowane.

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

This zawiera przykłady muteksów.

Answer 3

To, co chcesz osiągnąć, to mieć wiele wątków/pracowników i jednego obserwatora. Ten ostatni musi wykonywać swoją pracę tylko wtedy, gdy wszyscy pracownicy są gotowi/sygnał. W takim przypadku sprawdź kod w tym SO q/a. std::condition_variable - Wait for several threads to notify observer

Answer 4

Mutex to bardzo miła rzecz, gdy próbujesz uniknąć datariaces i jestem pewien, że odpowiedź wysłana przez @Phantom zadowoli większość ludzi. Należy jednak wiedzieć, że nie jest to skalowalne dla dużych systemów.

Blokując synchronizujesz wątki. Ponieważ dostęp do wektora może uzyskać tylko jedna osoba, zapisanie wątku w kontenerze spowoduje, że drugie oczekiwanie na jego zakończenie ... może być dobre dla ciebie, ale powoduje poważne zranienie wydajności, gdy wymagana jest wysoka wydajność.

Najlepszym rozwiązaniem byłoby zastosowanie bardziej złożonej struktury wolnej od blokady. Niestety nie sądzę, by w STL istniała standardowa struktura bez blokady.Jeden exemple kolejki lockfree jest dostępny here

Stosując taką strukturę, swoje 4 wątków roboczych będzie mógł enqueue wiadomości do pojemnika podczas 5th można by je dequeue, bez dataraces

More on lockfree datastructure can be found here !