Comment implémenter des structures de données thread-safe dans les fonctions C++ ?

Comment implémenter des structures de données thread-safe dans les fonctions C++ ? Utilisez des verrous mutex pour protéger les sections critiques (données partagées). Exemple de tableau dynamique thread-safe : utilisation d'un mutex pour protéger les données dans un std :: vector. Cas pratique : file d'attente thread-safe, utilisant des verrous mutex et des variables de condition pour assurer la sécurité des threads des files d'attente de messages.

Comment implémenter des structures de données thread-safe dans les fonctions C++ ?

Dans les applications multithread, l'accès simultané aux données partagées peut entraîner des conditions de concurrence critique et une corruption des données. Par conséquent, il est crucial de rendre les structures de données partagées thread-safe pour garantir que chaque thread peut accéder et modifier les données en toute sécurité.

Un moyen simple d'implémenter des structures de données thread-safe consiste à utiliser des verrous mutex. Un mutex est une primitive de synchronisation qui permet à un seul thread d'accéder à une section critique (données partagées) à la fois. L'exemple de code suivant montre comment utiliser un mutex pour protéger les données dans un tableau dynamique :

#include <mutex>
#include <vector>

std::mutex m;

// 线程安全的动态数组
class ThreadSafeVector {
public:
    void push_back(int value) {
        std::lock_guard<std::mutex> lock(m);
        v.push_back(value);
    }
    
    int get(size_t index) {
        std::lock_guard<std::mutex> lock(m);
        return v[index];
    }

private:
    std::vector<int> v;
};

int main() {
    ThreadSafeVector v;
    v.push_back(1);
    int value = v.get(0);
    // ...
}

Dans cet exemple, std::lock_guard est utilisé comme wrapper RAII (acquisition de ressources, c'est-à-dire initialisation), qui est utilisé lors de l'entrée dans une section critique. Acquérir automatiquement le verrou mutex à la sortie de la section critique et libérer automatiquement le verrou mutex à la sortie de la section critique. Cela garantit qu'un seul thread peut accéder au vecteur v à la fois. std::lock_guard 用作 RAII（资源获取即初始化）封装，它在进入临界区时自动获取互斥锁，并在退出临界区时自动释放互斥锁。这确保了在同一时间只有一个线程能访问 v 向量。

实战案例：线程安全的队列

假设我们有一个多线程应用程序，线程需要共享一个消息队列。为了使队列线程安全，可以使用互斥锁和条件变量来实现：

#include <mutex>
#include <condition_variable>
#include <queue>

std::mutex m;
std::condition_variable cv;

class ThreadSafeQueue {
public:
    void push(int value) {
        std::lock_guard<std::mutex> lock(m);
        q.push(value);
        cv.notify_one();
    }
    
    int pop() {
        std::unique_lock<std::mutex> lock(m);
        cv.wait(lock, [this]{ return !q.empty(); });
        int value = q.front();
        q.pop();
        return value;
    }

private:
    std::queue<int> q;
};

int main() {
    ThreadSafeQueue q;
    // ...
}

在这种情况下，std::condition_variable 用于通知线程队列中是否有新的消息。std::unique_lock 用于锁定和解锁互斥锁，同时还可以通过 cv.wait()

🎜Cas pratique : file d'attente thread-safe🎜🎜🎜Supposons que nous ayons une application multithread et que les threads doivent partager une file d'attente de messages. Pour rendre la file d'attente thread-safe, cela peut être réalisé en utilisant un mutex et une variable de condition : 🎜rrreee🎜 Dans ce cas, std::condition_variable est utilisé pour avertir le thread s'il y a un nouveau message. dans la file d'attente. std::unique_lock est utilisé pour verrouiller et déverrouiller les mutex, et peut également mettre le thread en veille via la méthode cv.wait() jusqu'à ce qu'il y ait de nouveaux messages dans 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!