Quels sont les types et les utilisations des verrous dans la programmation multithread C++ ?

Les types de verrous dans la programmation multithread C++ incluent : Verrous mutex : garantissent qu'un seul thread est autorisé à accéder aux ressources partagées à la fois. Verrous en lecture-écriture : permettent à plusieurs threads de lire les ressources partagées en même temps, mais uniquement. un thread peut y écrire à la fois. Spin locks : Vérifiez constamment l'état du verrou pour éviter d'attendre que le verrou soit disponible. Variable de condition : utilisée pour attendre qu'une certaine condition soit remplie

La. type et objectif du verrou dans la programmation multithread C++

Lock est utilisé dans la programmation multithread Un outil important pour coordonner l'accès des threads aux ressources partagées. En C++, il existe plusieurs types de verrous, chacun ayant son propre objectif.

1. Verrouillage Mutex (Mutex)

Le verrouillage Mutex est le type de verrouillage le plus basique, qui permet à un seul thread d'accéder à la section critique (ressource partagée) à la fois.

// 创建一个互斥锁
std::mutex mtx;

// 获取互斥锁（线程等待直到锁可用）
mtx.lock();

// 使用临界区
// ...

// 释放互斥锁（允许其他线程获取锁）
mtx.unlock();

2. Verrouillage en lecture-écriture (RWLock)

Le verrouillage en lecture-écriture permet à plusieurs threads de lire les ressources partagées en même temps, mais un seul thread peut écrire à la fois.

// 创建一个读写锁
std::shared_timed_mutex rwmtx;

// 获取读锁（线程可以在其他线程读取时读取）
rwmtx.lock_shared();

// 获取写锁（线程必须独占访问共享资源）
rwmtx.lock();

// 读取或写入临界区
// ...

// 释放锁
rwmtx.unlock();
rwmtx.unlock_shared();

3. Spinlock (Spinlock)

Un verrou tournant est similaire à un verrou mutex, mais lorsque le verrou n'est pas disponible, le verrou tournant vérifiera en permanence l'état du verrou au lieu d'attendre.

// 创建一个自旋锁
std::atomic_flag spinlock = ATOMIC_FLAG_INIT;

// 获取自旋锁
while (spinlock.test_and_set(std::memory_order_acquire));

// 使用临界区
// ...

// 释放自旋锁
spinlock.clear(std::memory_order_release);

4. Variable de condition

La variable de condition est utilisée pour attendre qu'une certaine condition soit remplie. Il est utilisé conjointement avec un verrou mutex pour permettre à un thread d'attendre lorsqu'une condition n'est pas remplie et réveille le thread pour poursuivre son exécution.

// 创建一个条件变量
std::condition_variable cv;

// 获取互斥锁
std::mutex mtx;
mtx.lock();

// 等待条件满足
cv.wait(mtx);

// 执行被唤醒后的操作
// ...

// 释放互斥锁
mtx.unlock();

Exemple pratique

Considérons une application qui contient une file d'attente thread-safe. La structure de file d'attente contient un mutex qui protège les opérations de file d'attente.

class Queue {
    private:
        std::queue<int> queue;
        std::mutex mtx;
    public:
        void push(int value) {
            std::lock_guard<std::mutex> lock(mtx);
            queue.push(value);
        }

        int pop() {
            std::lock_guard<std::mutex> lock(mtx);
            int value = queue.front();
            queue.pop();
            return value;
        }
};

Dans un environnement multithread, un mutex garantit qu'un seul thread peut accéder à la file d'attente à la fois, évitant ainsi les courses de données et la corruption de la file d'attente.

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!