Wie implementiert man Thread-Sicherheit im C++-Klassendesign?

Um Thread-Sicherheit zu erreichen, gibt es in C++ zwei Methoden: Verwenden Sie einen Mutex, um den kritischen Abschnitt zu schützen, sodass jeweils nur ein Thread darauf zugreifen kann. Mithilfe atomarer Operationen werden Vorgänge unteilbar ausgeführt, wodurch Probleme beim gleichzeitigen Zugriff vermieden werden.

Thread-Sicherheit im C++-Klassendesign implementieren

Einführung

In einer Multithread-Umgebung ist es von entscheidender Bedeutung, die Thread-Sicherheit von Daten sicherzustellen. In C++ gibt es mehrere Möglichkeiten, dies zu erreichen. In diesem Artikel wird untersucht, wie Mutexe und atomare Operationen zum Entwerfen threadsicherer Klassen verwendet werden.

Mutex

Ein Mutex ist ein Sperrmechanismus, der es jeweils nur einem Thread ermöglicht, auf einen kritischen Abschnitt zuzugreifen. Wenn ein Thread den kritischen Abschnitt betritt, erwirbt er den Besitz des Mutex. Andere Threads, die versuchen, in den kritischen Abschnitt einzudringen, werden blockiert, bis der Thread den Mutex freigibt.

class ThreadSafeCounter {
private:
    std::mutex m_mutex;
    int m_count;

public:
    void increment() {
        std::lock_guard<std::mutex> lock(m_mutex);
        ++m_count;
    }

    int get() {
        std::lock_guard<std::mutex> lock(m_mutex);
        return m_count;
    }
};

Im obigen Beispiel verwenden sowohl die Methoden increment() als auch get() den std::mutex aus der Standardbibliothek kritischen Bezirk schützen. Während ein Thread die Anzahl aktualisiert, können andere Threads nicht gleichzeitig die Methode increment() aufrufen. increment() 和 get() 方法都使用标准库中的 std::mutex 保护临界区。当一个线程正在更新计数时，其他线程无法同时进入 increment() 方法。

原子操作

原子操作是一种特殊类型的操作，它以不可分割的方式执行。这意味着一次只能在单个线程中执行这些操作，从而消除了并发访问引发的问题。C++11 中引入了 std::atomic 库，它提供了用于原子操作的类。

class ThreadSafeCounterAtomic {
private:
    std::atomic<int> m_count;

public:
    void increment() {
        ++m_count;
    }

    int get() {
        return m_count.load();
    }
};

在本例中，m_count 是一个原子整数，可以安全地从多个线程中进行增量和获取。std::atomic<int>::load()

Atomoperationen

Atomoperationen sind eine besondere Art von Operationen, die unteilbar ausgeführt werden. Dies bedeutet, dass diese Vorgänge jeweils nur in einem einzelnen Thread ausgeführt werden können, wodurch Probleme durch gleichzeitigen Zugriff vermieden werden. C++11 führte die Bibliothek std::atomic ein, die Klassen für atomare Operationen bereitstellt.

#include <thread>

int main() {
    std::unique_ptr<ThreadSafeCounter> counter = std::make_unique<ThreadSafeCounter>();

    std::vector<std::thread> threads(10);
    for (auto& thread : threads) {
        thread = std::thread([&] {
            for (int i = 0; i < 1000000; ++i) {
                counter->increment();
            }
        });
    }

    for (auto& thread : threads) {
        thread.join();
    }

    std::cout << "最终计数：" << counter->get() << std::endl;
}

In diesem Fall ist m_count eine atomare Ganzzahl, die sicher erhöht und von mehreren Threads abgerufen werden kann. Die Methode std::atomic<int>::load() ruft den Wert einer atomaren Ganzzahl auf threadsichere Weise ab.

Praktischer Fall

Betrachten Sie ein Beispiel eines gemeinsamen Zählers, der parallel von mehreren Threads aktualisiert werden muss:

rrreee

In diesem Programm aktualisieren wir den Zähler parallel von 10 Threads und drucken dann die endgültige Zählung im aus Haupt-Bedroung. Der Mutex stellt sicher, dass der Zähler zu jedem Zeitpunkt nur von höchstens einem Thread aktualisiert werden kann und gewährleistet so die Thread-Sicherheit. 🎜🎜🎜Fazit🎜🎜🎜Thread-sichere C++-Klassen können mithilfe von Mutexes und atomaren Operationen entworfen werden. Mutexe eignen sich zum Schutz kritischer Abschnitte, die seriellen Zugriff erfordern, während atomare Operationen für Operationen geeignet sind, die keinen seriellen Zugriff erfordern und atomar ausgeführt werden können. 🎜

Das obige ist der detaillierte Inhalt vonWie implementiert man Thread-Sicherheit im C++-Klassendesign?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!