C++ 11: seguro de bloqueo comprobado doble para la inicialización perezosa. ¿Posible?

Question

He leído muchas preguntas teniendo en cuenta el bloqueo comprobado doble seguro para subprocesos (para singletons o init perezoso). En algunos hilos, la respuesta es que el patrón está completamente roto, otros sugieren una solución.

Así que mi pregunta es: ¿hay alguna manera de escribir un patrón de bloqueo comprobado completamente seguro para subprocesos en C++? Si es así, ¿cómo se ve?

Podemos suponer que C++ 11, si eso hace las cosas más fáciles. Por lo que sé, C++ 11 mejoró el modelo de memoria que podría producir las mejoras necesarias.

Sé que es posible hacerlo en Java haciendo que la variable de doble verificación sea volátil. Como C++ 11 tomó prestadas partes grandes del modelo de memoria de Java, entonces creo que podría ser posible, pero ¿cómo?

Answer 1

Utilice simplemente una variable local estática para Singleton perezosamente inicializados, así:

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

El (C++ 11) estándar ya garantiza que las variables estáticas se inicializan de manera multi-hilo y parece probable que la implementación de esto al menos tan robusto y eficiente como cualquier cosa que usted mismo escriba.

El threadsafety de la inicialización se puede encontrar en §6.7.4 de la (C++ 11) estándar:

Si el control entra en la declaración simultáneamente mientras que la variable se inicializa, la ejecución concurrente deberá espere a que finalice la inicialización.

Answer 2

Como quería ver una implementación válida de DCLP C++ 11, aquí tiene una.

El comportamiento es totalmente seguro para subprocesos e idéntico al GetInstance() en la respuesta de 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; 
}