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

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

WBOY

Freigeben： 2024-06-02 21:20:01

Original

332 Leute haben es durchsucht

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.

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

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;

Nach dem Login kopieren

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

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

Nach dem Login kopieren

条件变量

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

std::condition_variable cv;

Nach dem Login kopieren

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

cv.wait(mutex);

Nach dem Login kopieren

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

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

Nach dem Login kopieren

读写锁

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

std::shared_mutex rw_mutex;

Nach dem Login kopieren

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

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

Nach dem Login kopieren

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();

Nach dem Login kopieren

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;
};

Nach dem Login kopieren

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;
};

Nach dem Login kopieren

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!