È sicuro il thread unique_ptr?

Question

È sicuro un thread unique_ptr? È impossibile che il codice sottostante stampi lo stesso numero due volte?

#include <memory> 
#include <string> 
#include <thread> 
#include <cstdio> 

using namespace std; 

int main() 
{ 
    unique_ptr<int> work; 

    thread t1([&] { 
     while (true) { 
      const unique_ptr<int> localWork = move(work); 
      if (localWork) 
       printf("thread1: %d\n", *localWork); 
      this_thread::yield(); 
     } 
    }); 

    thread t2([&] { 
     while (true) { 
      const unique_ptr<int> localWork = move(work); 
      if (localWork) 
       printf("thread2: %d\n", *localWork); 
      this_thread::yield(); 
     } 
    }); 

    for (int i = 0; ; i++) { 
     work.reset(new int(i)); 

     while (work) 
      this_thread::yield(); 
    } 

    return 0; 
} 

Answer 1

No, non è thread-safe .

Entrambi i thread possono potenzialmente move il puntatore di lavoro senza sincronizzazione esplicita, quindi è possibile che entrambi i thread ottengano lo stesso valore, o entrambi per ottenere un puntatore non valido ... è un comportamento non definito.

Se si vuole fare qualcosa di simile correttamente, probabilmente è necessario usare qualcosa come std::atomic_exchange in modo da entrambi i fili in grado di leggere/modificare il puntatore del lavoro condiviso con la semantica di destra.

Answer 2

Secondo Msdn:

Il seguente sicurezza filo regole si applicano a tutte le classi Standard C++ Library (tranne le classi shared_ptr e iostream, come descritto di seguito ).

Un singolo oggetto è thread-safe per la lettura da più thread. Per esempio , dato un oggetto A, è sicuro leggere A dal thread 1 e dal thread 2 contemporaneamente.

Se un singolo oggetto viene scritto da un thread, quindi tutti i valori e le scritture su quell'oggetto sullo stesso o su altri thread devono essere protetti da . Ad esempio, dato un oggetto A, se il thread 1 sta scrivendo su A, al thread 2 deve essere impedito di leggere o scrivere in A.

È sicuro leggere e scrivere su un'istanza di un tipo anche se un altro thread sta leggendo o scrivendo su un'altra istanza dello stesso tipo. Per esempio, dati oggetti A e B dello stesso tipo, è sicuro se A è stato scritto in filo 1 e B vengono letti in filo 2.

Answer 3

unique_ptr è thread-safe se usato correttamente. Hai infranto la regola non scritta: non passerai mai unique_ptr tra i thread per riferimento.

La filosofia dietro unique_ptr è che ha un unico (unico) proprietario in ogni momento. Per questo motivo, puoi sempre passare in sicurezza tra i thread senza sincronizzazione, ma devi passarlo per valore, non per riferimento. Una volta creati alias su un unique_ptr, si perde la proprietà di unicità e tutte le scommesse sono disattivate. Sfortunatamente il C++ non può garantire l'unicità, quindi ti rimane una convenzione che devi seguire religiosamente. Non creare alias su un unique_ptr!