Comment implémenter un singleton multithread en C 11 sans mutex ?

Implémentation de singleton multithread en C 11 sans mutex

Avec l'introduction des capacités multithreading en C 11, la question se pose de savoir comment implémenter des singletons sans utiliser de mutex pour l’optimisation des performances. Une approche suggérée implique l'utilisation de variables atomiques et la fonction std::atomic_compare_exchange_strong() :

<code class="cpp">class Singleton
{
public:
    static bool isInitialized() { return (flag == 2); }
    static bool initizalize(const string& name_)
    {
        if (flag == 2)
            return false;
        if (flag == 1)
            return false;
        int exp = 0;
        int desr = 1;
        bool willInitialize = std::atomic_compare_exchange_strong(&flag, &exp, desr);
        if (!willInitialize)
        {
            cout << "Somebody else CASed at aprox same time" << endl;
            return false;
        }
        else
        {
            initialize_impl(name_);
            assert(flag == 1);
            flag = 2;
            return true;
        }
    }
    static void clear()
    {
        name.clear();
        flag = 0;
    }

private:
    static void initialize_impl(const string& name_) { name = name_; }
    static atomic<int> flag;
    static string name;
};</code>

Les variables atomiques et la fonction std::atomic_compare_exchange_strong() assurent la sécurité des threads sans introduire de surcharge de synchronisation des threads. Cependant, cette approche nécessite toujours une manipulation prudente pour éviter les courses de données et garantir une initialisation correcte.

La norme C 11 applique la sécurité de l'initialisation

Fait intéressant, la norme C 11 élimine le besoin de verrouillage manuel dans certains scénarios. L'extrait de code suivant exploite ce comportement :

<code class="cpp">static Singleton& get() {
  static Singleton instance;
  return instance;
}</code>

L'exécution simultanée tentant d'initialiser l'instance de variable statique attendra implicitement son achèvement, réduisant ainsi les conditions de concurrence potentielles.

Singleton Anti- Modèle

Bien que les approches ci-dessus fournissent des solutions pour la mise en œuvre de singletons multithread, il convient de noter que l'utilisation de singletons est généralement déconseillée. Ils peuvent introduire du couplage, des dépendances d’état et compliquer les tests unitaires. Des modèles de conception alternatifs sont souvent préférables pour gérer les ressources partagées et les dépendances.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!