Wie implementiert man Thread-Sicherheit in C++?

In einer Multithread-Umgebung ist es wichtig, Thread-Sicherheit zu implementieren, um Datenbeschädigungen zu vermeiden. Die folgenden Mechanismen stehen in C++ zur Verfügung: 1. Mutex-Sperre (std::mutex) stellt sicher, dass jeweils nur ein Thread auf gemeinsam genutzte Daten zugreifen darf. 2. Bedingungsvariable (std::condition_variable) ermöglicht es Threads, auf eine bestimmte Zeit zu warten Bedingung muss wahr sein; 3. Lese-/Schreibsperre (std::shared_mutex) ermöglicht es mehreren Threads, gemeinsam genutzte Daten gleichzeitig zu lesen, aber nur ein Thread kann schreiben. Diese Mechanismen gewährleisten die Stabilität und Datenintegrität von Programmen in Multithread-Umgebungen, indem sie den Zugriff verschiedener Threads auf gemeinsam genutzte Ressourcen synchronisieren.

Thread-sichere Implementierung in C++

Einführung

Wenn in einer Multithread-Umgebung mehrere Threads gleichzeitig ohne Synchronisierung auf gemeinsam genutzte Daten zugreifen, kann dies zu Datenbeschädigung oder Anwendungsabsturz führen. Um solche Probleme zu verhindern, müssen wir Thread-Sicherheit implementieren.

Mutex-Sperre

Eine Mutex-Sperre ist ein Synchronisationsprimitiv, das jeweils nur einem Thread den Zugriff auf einen bestimmten Teil des Codes oder der Daten ermöglicht. In C++ können Sie std::mutex verwenden, um eine Mutex-Sperre zu erstellen, wie unten gezeigt: std::mutex 来创建互斥锁，如下所示：

std::mutex m;

要获取互斥锁，请使用 lock() 方法：

m.lock();

当不再需要时释放互斥锁：

m.unlock();

互斥锁的优点是简单易用，但缺点是如果一个线程长时间持有互斥锁，则其他线程可能需要很长时间才能获得互斥锁。

条件变量

条件变量与互斥锁一起使用，允许线程等待某个条件变为真。在 C++ 中，可以使用 std::condition_variable 来创建条件变量，如下所示：

std::condition_variable cv;

要等待条件变量，请使用 wait() 方法，如下所示：

m.lock();
cv.wait(m);
m.unlock();

这将使线程进入休眠状态，直到另一个线程使用 cv.notify_one() 或 cv.notify_all() 唤醒它。

读写锁

读写锁是一种特殊的互斥锁，它允许多个线程同时读取共享数据，但一次只能允许一个线程写入共享数据。在 C++ 中，可以使用 std::shared_mutex 来创建读写锁，如下所示：

std::shared_mutex rw;

要获取读锁，请使用 lock_shared() 方法：

rw.lock_shared();

要获取写锁，请使用 lock()

rw.lock();

Um eine Mutex-Sperre zu erhalten, verwenden Sie die Methode lock():

class BankAccount {
    std::mutex m;
    std::condition_variable cv;
    int balance;

public:
    int get_balance() {
        m.lock();
        int b = balance;
        m.unlock();
        return b;
    }

    void deposit(int amount) {
        m.lock();
        balance += amount;
        cv.notify_all();
        m.unlock();
    }

    void withdraw(int amount) {
        m.lock();
        while (balance < amount) {
            cv.wait(m);
        }
        balance -= amount;
        m.unlock();
    }
};

Geben Sie den Mutex frei, wenn er nicht mehr benötigt wird: rrreeeDer Vorteil eines Mutex besteht darin, dass er einfach und leicht zu verwenden ist. Der Nachteil besteht jedoch darin, dass es lange dauern kann, wenn ein Thread den Mutex für längere Zeit hält Zeit für andere Threads, die Mutex-Sperre zu erhalten.

Bedingte Variablen

🎜🎜Bedingte Variablen werden mit Mutex-Sperren verwendet, um einem Thread zu ermöglichen, darauf zu warten, dass eine bestimmte Bedingung wahr wird. In C++ können Sie mit std::condition_variable eine Bedingungsvariable erstellen, wie unten gezeigt: 🎜rrreee🎜Um auf eine Bedingungsvariable zu warten, verwenden Sie die Methode wait() wie gezeigt unten Zeigt an: 🎜rrreee🎜Dadurch wird der Thread in den Ruhezustand versetzt, bis ein anderer Thread ihn mit cv.notify_one() oder cv.notify_all() aufweckt. 🎜🎜🎜Lese-/Schreibsperre🎜🎜🎜Die Lese-/Schreibsperre ist eine spezielle Mutex-Sperre, die es mehreren Threads ermöglicht, gemeinsam genutzte Daten gleichzeitig zu lesen, aber jeweils nur einem Thread das Schreiben gemeinsam genutzter Daten ermöglicht. In C++ können Sie std::shared_mutex verwenden, um eine Lese-/Schreibsperre wie folgt zu erstellen: 🎜rrreee🎜Um eine Lesesperre zu erhalten, verwenden Sie die Methode lock_shared(): 🎜rrreee🎜Um eine Schreibsperre zu erhalten, verwenden Sie die Methode lock(): 🎜rrreee🎜🎜Ein praktisches Beispiel🎜🎜🎜Angenommen, wir haben eine Bankkontoklasse, die Kontostände verfolgt: 🎜rrreee🎜Hier Beispielsweise verwenden wir einen Mutex, um die Saldovariable zu schützen, und eine Bedingungsvariable, um dem Thread zu ermöglichen, zu warten, wenn der Saldo nicht ausreicht, um die Auszahlung zu erfüllen. 🎜

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