Wie gehe ich mit der Parallelitätskontrolle im C++-Klassendesign um?

Die Parallelitätskontrolle in C++ verwendet Mechanismen wie Mutexe (ein Zugriff auf kritische Abschnitte), Bedingungsvariablen (Warten auf erfüllte Bedingungen) und Lese-/Schreibsperren (die es mehreren Lesern ermöglichen, gleichzeitig zu lesen, aber nur einem zu schreiben). um gemeinsam genutzte Ressourcen zu lösen. Datenrennen und inkonsistente Zustände, die durch gleichzeitigen Zugriff verursacht werden.

Parallelitätskontrolle im C++-Klassendesign

Einführung

In einer Multithread-Umgebung kann der gleichzeitige Zugriff auf gemeinsam genutzte Ressourcen zu Datenwettläufen und inkonsistenten Zuständen führen. Um dieses Problem zu lösen, bietet C++ eine Vielzahl von Mechanismen zur Steuerung der Parallelität.

Mutex

Ein Mutex ist ein Synchronisationsprimitiv, das jeweils nur einem Thread den Zugriff auf einen kritischen Abschnitt ermöglicht. Wir können die Klasse std::mutex verwenden, um einen Mutex zu erstellen: std::mutex 类来创建一个互斥量：

std::mutex mutex;

要访问临界区，线程必须获取互斥量的锁：

mutex.lock();
// 访问临界区
mutex.unlock();

条件变量

条件变量是一个同步原语，它允许一个线程等待另一个线程完成特定的条件。我们可以使用 std::condition_variable 类来创建一个条件变量：

std::condition_variable cv;

线程可以通过调用 wait() 方法来等待条件：

cv.wait(mutex);

当条件满足时，另一個執行緒可以呼叫 notify_one() 或 notify_all() 方法來通知等待的執行緒：

cv.notify_one();
cv.notify_all();

读写锁

读写锁是一种同步原语，它允许多个线程同时读取共享资源，但一次只有一个线程可以写入共享资源。我们可以使用 std::shared_mutex

std::shared_mutex rw_mutex;

Um auf den kritischen Abschnitt zuzugreifen, muss der Thread die Sperre des Mutex erwerben:

rw_mutex.lock_shared();
// 读取共享资源
rw_mutex.unlock_shared();

Bedingungsvariable

Die Bedingungsvariable ist ein Synchronisierungsprimitiv, das es einem Thread ermöglicht, darauf zu warten, dass ein anderer Thread eine bestimmte Bedingung erfüllt. Wir können die Klasse std::condition_variable verwenden, um eine Bedingungsvariable zu erstellen:

rw_mutex.lock();
// 写入共享资源
rw_mutex.unlock();

Threads können auf die Bedingung warten, indem sie die Methode wait() aufrufen:

class BankAccount {
public:
    BankAccount(int initial_balance) : balance(initial_balance) {}
    
    void deposit(int amount) {
        balance += amount;
    }
    
    void withdraw(int amount) {
        if (amount <= balance) {
            balance -= amount;
        }
    }
    
private:
    int balance;
};

When Wenn die Bedingung erfüllt ist, kann ein anderer Thread die Methode notify_one() oder notify_all() aufrufen, um den wartenden Thread zu benachrichtigen:

class BankAccount {
public:
    BankAccount(int initial_balance) : balance(initial_balance) {}
    
    void deposit(int amount) {
        std::lock_guard<std::mutex> lock(mutex);
        balance += amount;
    }
    
    void withdraw(int amount) {
        std::lock_guard<std::mutex> lock(mutex);
        if (amount <= balance) {
            balance -= amount;
        }
    }
    
private:
    std::mutex mutex;
    int balance;
};

Lese-/Schreibsperre

Lese-/Schreibsperre lock ist ein Synchronisierungsprimitiv, das es mehreren Threads ermöglicht, gleichzeitig von einer gemeinsam genutzten Ressource zu lesen, aber jeweils nur ein Thread kann auf die gemeinsam genutzte Ressource schreiben. Wir können die Klasse std::shared_mutex verwenden, um Lese-/Schreibsperren zu erstellen: 🎜rrreee🎜Um gemeinsam genutzte Ressourcen zu lesen, können Threads Lesesperren erwerben: 🎜rrreee🎜Um auf gemeinsam genutzte Ressourcen zu schreiben, können Threads Schreibzugriffe erhalten Sperren:🎜rrreee🎜Praktischer Fall🎜🎜Stellen Sie sich eine einfache Bankkontoklasse vor, die eine Saldo-Mitgliedsvariable und eine Methode für Ein- und Auszahlungen enthält:🎜rrreee🎜Um den gleichzeitigen Zugriff zu handhaben, können wir einen Mutex verwenden, um die Saldo-Mitgliedsvariable zu schützen: 🎜 rrreee🎜 Jetzt können wir von mehreren Threads aus sicher gleichzeitig auf Bankkonten zugreifen. 🎜

Das obige ist der detaillierte Inhalt vonWie gehe ich mit der Parallelitätskontrolle im C++-Klassendesign um?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!