Wie implementiert man einen Multithread-Singleton in C 11 ohne Mutexe?

Implementierung von Multithread-Singleton in C 11 ohne Mutexe

Mit der Einführung von Multithreading-Funktionen in C 11 stellt sich die Frage, wie Singletons implementiert werden ohne Mutexe zur Leistungsoptimierung zu verwenden. Ein vorgeschlagener Ansatz beinhaltet die Verwendung atomarer Variablen und der Funktion 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>

Atomvariablen und der Funktion std::atomic_compare_exchange_strong() gewährleisten Thread-Sicherheit, ohne einen Mehraufwand für die Thread-Synchronisierung zu verursachen. Dieser Ansatz erfordert jedoch immer noch eine sorgfältige Handhabung, um Datenwettläufe zu verhindern und eine ordnungsgemäße Initialisierung sicherzustellen.

Der C 11-Standard erzwingt die Initialisierungssicherheit.

Interessanterweise macht der C 11-Standard dies überflüssig manuelles Sperren in bestimmten Szenarien. Der folgende Codeausschnitt nutzt dieses Verhalten aus:

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

Die gleichzeitige Ausführung, die versucht, die statische Variableninstanz zu initialisieren, wartet implizit auf deren Abschluss, wodurch potenzielle Race-Bedingungen reduziert werden.

Singleton Anti- Muster

Während die oben genannten Ansätze Lösungen für die Multithread-Singleton-Implementierung bieten, ist es erwähnenswert, dass von der Verwendung von Singletons im Allgemeinen abgeraten wird. Sie können Kopplungen und Zustandsabhängigkeiten einführen und Unit-Tests erschweren. Alternative Entwurfsmuster sind oft für die Verwaltung gemeinsamer Ressourcen und Abhängigkeiten vorzuziehen.

Das obige ist der detaillierte Inhalt vonWie implementiert man einen Multithread-Singleton in C 11 ohne Mutexe?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!