Comment implémenter la sécurité des threads en C++ ?

Dans un environnement multithread, il est crucial de mettre en œuvre la sécurité des threads pour éviter la corruption des données. Les mécanismes suivants sont fournis en C++ : 1. Le verrouillage mutex (std::mutex) garantit qu'un seul thread est autorisé à accéder aux données partagées à la fois. 2. La variable de condition (std::condition_variable) permet aux threads d'attendre un moment spécifique ; la condition doit être vraie ; 3. Le verrouillage en lecture-écriture (std::shared_mutex) permet à plusieurs threads de lire les données partagées simultanément, mais un seul thread peut écrire. Ces mécanismes garantissent la stabilité et l'intégrité des données des programmes dans des environnements multithread en synchronisant l'accès aux ressources partagées par différents threads.

Implémentation Thread-Safe en C++

Introduction

Dans un environnement multithread, si plusieurs threads accèdent aux données partagées en même temps sans synchronisation, cela peut entraîner une corruption des données ou un crash de l'application. Pour éviter de tels problèmes, nous devons implémenter la sécurité des threads.

Mutex Lock

Un verrou mutex est une primitive de synchronisation qui permet à un seul thread d'accéder à une certaine partie du code ou des données à la fois. En C++, vous pouvez utiliser std::mutex pour créer un verrou mutex, comme indiqué ci-dessous : 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();

Pour obtenir un verrou mutex, utilisez la méthode 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();
    }
};

Relâchez le mutex lorsque vous n'en avez plus besoin : rrreeeL'avantage d'un mutex est qu'il est simple et facile à utiliser, mais l'inconvénient est que si un thread maintient le mutex pendant une longue période, cela peut prendre beaucoup de temps il est temps pour les autres threads d'obtenir le verrouillage Mutex.

Variables conditionnelles

🎜🎜Les variables conditionnelles sont utilisées avec les verrous mutex pour permettre à un thread d'attendre qu'une certaine condition devienne vraie. En C++, vous pouvez créer une variable de condition en utilisant std::condition_variable comme indiqué ci-dessous : 🎜rrreee🎜Pour attendre une variable de condition, utilisez la méthode wait() comme indiqué ci-dessous Indique : 🎜rrreee🎜Cela mettra le fil en veille jusqu'à ce qu'un autre fil le réveille en utilisant cv.notify_one() ou cv.notify_all(). 🎜🎜🎜Verrouillage en lecture-écriture🎜🎜🎜Le verrouillage en lecture-écriture est un verrou mutex spécial qui permet à plusieurs threads de lire des données partagées en même temps, mais ne permet qu'à un seul thread d'écrire des données partagées à la fois. En C++, vous pouvez utiliser std::shared_mutex pour créer un verrou en lecture-écriture comme suit : 🎜rrreee🎜Pour acquérir un verrou en lecture, utilisez la méthode lock_shared() : 🎜 rrreee🎜Pour acquérir un verrou en écriture, utilisez la méthode lock() : 🎜rrreee🎜🎜Un exemple pratique🎜🎜🎜Supposons que nous ayons une classe de comptes bancaires qui suit les soldes des comptes : 🎜rrreee🎜Dans ce Par exemple, nous utilisons un mutex pour protéger la variable de solde et une variable de condition pour permettre au thread d'attendre lorsque le solde est insuffisant pour satisfaire le retrait. 🎜

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!