Comment gérer le contrôle de concurrence dans la conception de classes C++ ?

Le contrôle de concurrence en C++ utilise des mécanismes tels que les mutex (un seul accès aux sections critiques), les variables de condition (en attente que les conditions soient remplies), les verrous en lecture-écriture (permettant à plusieurs lecteurs de lire en même temps, mais à un seul d'écrire) pour résoudre les ressources partagées Courses de données et états incohérents causés par un accès simultané.

Contrôle de la concurrence dans la conception de classes C++

Introduction

Dans un environnement multithread, l'accès simultané aux ressources partagées peut conduire à des courses de données et à des états incohérents. Pour résoudre ce problème, C++ fournit une variété de mécanismes pour gérer le contrôle de concurrence.

Mutex

Un mutex est une primitive de synchronisation qui permet à un seul thread d'accéder à une section critique à la fois. On peut utiliser la classe std::mutex pour créer un mutex : 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;

Pour accéder à la section critique, le thread doit acquérir le verrou du mutex :

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

Variable de condition

La variable de condition est une primitive de synchronisation qui permet à un thread d'attendre qu'un autre thread remplisse une condition spécifique. Nous pouvons utiliser la classe std::condition_variable pour créer une variable de condition :

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

Les threads peuvent attendre la condition en appelant la méthode wait() :

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 la condition est remplie, un autre thread peut appeler la méthode notify_one() ou notify_all() pour notifier le thread en attente :

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

verrouillage lecture-écriture

lecture-écriture lock est une primitive de synchronisation qui permet à plusieurs threads de lire simultanément une ressource partagée, mais un seul thread peut écrire sur la ressource partagée à la fois. Nous pouvons utiliser la classe std::shared_mutex pour créer des verrous en lecture-écriture : 🎜rrreee🎜Pour lire les ressources partagées, les threads peuvent acquérir des verrous en lecture : 🎜rrreee🎜Pour écrire sur des ressources partagées, les threads peuvent acquérir des verrous en écriture. locks :🎜rrreee🎜Cas pratique🎜🎜Considérons une classe de compte bancaire simple qui contient une variable membre du solde et une méthode pour les dépôts et les retraits :🎜rrreee🎜Pour gérer les accès simultanés, nous pouvons utiliser un mutex pour protéger le membre du solde Variable : 🎜 rrreee🎜 Nous pouvons désormais accéder en toute sécurité aux comptes bancaires simultanément à partir de plusieurs threads. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!