efficiente Singleton thread-safe in C++

Question

Il modello usuale per una classe Singleton è qualcosa di simile

static Foo &getInst() 
{ 
    static Foo *inst = NULL; 
    if(inst == NULL) 
    inst = new Foo(...); 
    return *inst;  
} 

Tuttavia, è la mia comprensione che questa soluzione non è thread-safe, dal momento che 1) il costruttore di Foo potrebbe essere chiamato più di una volta (che può o non può importare) e 2) inst può non essere completamente costruito prima che venga restituito a un thread diverso.

Una soluzione è racchiudere un mutex attorno all'intero metodo, ma poi sto pagando il sovraccarico della sincronizzazione per molto tempo dopo che ne ho effettivamente bisogno. Un'alternativa è qualcosa di simile

static Foo &getInst() 
{ 
    static Foo *inst = NULL; 
    if(inst == NULL) 
    { 
    pthread_mutex_lock(&mutex); 
    if(inst == NULL) 
     inst = new Foo(...); 
    pthread_mutex_unlock(&mutex); 
    } 
    return *inst;  
} 

È questo il modo giusto per farlo, o ci sono delle insidie ​​che dovrei essere a conoscenza? Ad esempio, ci sono problemi di ordine di inizializzazione statici che potrebbero verificarsi, vale a dire inst è sempre garantito che sia NULL la prima volta che viene chiamato getInst?

Answer 1

La soluzione si chiama 'blocco ricontrollato' e il modo che hai scritto non è threadsafe.

Questo Meyers/Alexandrescu paper spiega perché - ma quella carta è anche ampiamente fraintesa. Ha avviato il blocco "double checked locking is safe in C++", ma la sua conclusione effettiva è che il doppio blocco controllato in C++ può essere implementato in modo sicuro, richiede solo l'uso di barriere di memoria in un posto non ovvio.

La carta contiene pseudocodice che dimostra come utilizzare le barriere di memoria per implementare in modo sicuro il DLCP, quindi non dovrebbe essere difficile per voi correggere la vostra implementazione.

Answer 2

Utilizzare pthread_once, che garantisce che la funzione di inizializzazione venga eseguita una volta atomicamente.

(In Mac OS X si utilizza un blocco di selezione. Non so la realizzazione di altre piattaforme.)

Answer 3

TTBOMK, l'unico modo thread-safe garantito per fare questo senza bloccare sarebbe per inizializzare tutte le vostre singleton prima di si avvia una discussione.

Answer 4

L'alternativa si chiama "double-checked locking".

Ci potrebbe esistere modelli multi-threaded di memoria in cui opera, ma POSIX non garantisce una

Answer 5

L'implementazione di singleton ACE utilizza un modello di blocco a doppia verifica per la sicurezza della filettatura, è possibile fare riferimento se lo si desidera.

È possibile trovare il codice sorgente here.

Answer 6

Se si utilizza C++ 11, ecco un modo giusto per fare questo:

Foo& getInst() 
{ 
    static Foo inst(...); 
    return inst; 
} 

Secondo la nuova norma non v'è alcuna necessità di preoccuparsi di questo problema più. L'inizializzazione dell'oggetto verrà eseguita solo da un thread, gli altri thread attenderanno fino al completamento. Oppure puoi usare std :: call_once.(+ Info here)

Answer 7

Herb Sutter talks about the double-checked locking in CppCon 2014.

Di seguito è il codice ho implementato in C++ 11 sulla base di tale:

class Foo { 
public: 
    static Foo* Instance(); 
private: 
    Foo() {} 
    static atomic<Foo*> pinstance; 
    static mutex m_; 
}; 

atomic<Foo*> Foo::pinstance { nullptr }; 
std::mutex Foo::m_; 

Foo* Foo::Instance() { 
    if(pinstance == nullptr) { 
    lock_guard<mutex> lock(m_); 
    if(pinstance == nullptr) { 
     pinstance = new Foo(); 
    } 
    } 
    return pinstance; 
} 

è anche possibile controllare programma completo qui: http://ideone.com/olvK13