C++ 11: blocco doppio controllo sicuro per l'inizializzazione pigra. Possibile?

Question

Ho letto molte domande considerando il blocco a doppio controllo sicuro per thread (per singleton o init pigro). In alcuni thread, la risposta è che il pattern è completamente infranto, altri suggeriscono una soluzione.

Quindi la mia domanda è: esiste un modo per scrivere un modello di blocco a doppio controllo completamente protetto da thread in C++? Se è così, com'è?

Possiamo assumere C++ 11, se questo rende le cose più facili. Per quanto ne so, C++ 11 ha migliorato il modello di memoria che potrebbe produrre i miglioramenti necessari.

So che è possibile in Java rendendo volatile la variabile a doppio controllo controllata. Dal momento che C++ 11 ha preso in prestito grandi parti del modello di memoria da quello di Java, quindi penso che potrebbe essere possibile, ma come?

Answer 1

è sufficiente utilizzare un variabile locale statica per Singletons pigramente inizializzati, in questo modo:

MySingleton* GetInstance() { 
    static MySingleton instance; 
    return &instance; 
} 

L'(C++ 11) di serie garantisce già che le variabili statiche vengono inizializzate in modo threadsafe e sembra probabile che la l'implementazione di questo almeno altrettanto robusto e performante di qualsiasi cosa tu possa scrivere da solo.

La threadsafety di inizializzazione può essere trovato nel §6.7.4 del (C++ 11) Campione:

Se il controllo entra nella dichiarazione contemporaneamente mentre viene inizializzata la variabile, l'esecuzione concorrente deve attendere il completamento dell'inizializzazione.

Answer 2

Dato che si desidera visualizzare un'implementazione C++ 11 DCLP valida, eccone uno.

Il comportamento è completamente thread-safe e identico a GetInstance() nella risposta di Grizzly.

std::mutex mtx; 
std::atomic<MySingleton *> instance_p{nullptr}; 

MySingleton* GetInstance() 
{ 
    auto *p = instance_p.load(std::memory_order_acquire); 

    if (!p) 
    { 
     std::lock_guard<std::mutex> lck{mtx}; 

     p = instance_p.load(std::memory_order_relaxed); 
     if (!p) 
     { 
      p = new MySingleton; 
      instance_p.store(p, std::memory_order_release); 
     } 
    } 

    return p; 
}