Programmation concurrente C++ : comment effectuer une conception thread-safe de structures de données concurrentes ?

Conception de structure de données concurrentes thread-safe : méthode de mise en œuvre : type atomique et type atomique de verrouillage mutex : garantir que les accès multiples sont indivisibles et garantir la cohérence des données. Verrouillage mutex : restreint l'accès aux données partagées par un thread à la fois pour empêcher la corruption simultanée des données. Exemple : Thread-Safe Queue démontre une structure de données thread-safe implémentée à l'aide d'un verrou mutex.

Programmation simultanée C++ : conception de structure de données simultanées thread-safe

Comprendre la sécurité des threads

La sécurité des threads signifie que la structure de données est accessible simultanément par plusieurs threads sans corruption de données ni crash du programme. Dans la programmation simultanée C++, la sécurité des threads est cruciale.

Types atomiques et mutex

Types atomiques :
Les types atomiques garantissent que les accès multiples aux données sous-jacentes sont indivisibles pour garantir la cohérence. Par exemple, std::atomic<int></int> . std::atomic<int></int> 。

互斥锁：
互斥锁允许一个线程一次访问共享数据，从而防止并发访问导致的数据损坏。使用 std::mutex 。

实例：线程安全队列

以下是一个使用互斥锁实现的简单的线程安全队列：

#include <iostream>
#include <mutex>
#include <queue>

class ThreadSafeQueue {
private:
    std::queue<int> data;
    std::mutex mtx;

public:
    void push(int value) {
        std::lock_guard<std::mutex> lock(mtx);
        data.push(value);
    }

    int pop() {
        std::lock_guard<std::mutex> lock(mtx);
        if (data.empty()) throw std::runtime_error("Queue is empty");
        int value = data.front();
        data.pop();
        return value;
    }

    bool empty() {
        std::lock_guard<std::mutex> lock(mtx);
        return data.empty();
    }
};

int main() {
    ThreadSafeQueue queue;

    std::thread t1([&queue] {
        for (int i = 0; i < 1000; ++i) {
            std::lock_guard<std::mutex> lock(queue.mtx);
            queue.push(i);
        }
    });

    std::thread t2([&queue] {
        while (!queue.empty()) {
            std::lock_guard<std::mutex> lock(queue.mtx);
            std::cout << "Thread 2 popped: " << queue.pop() << std::endl;
        }
    });

    t1.join();
    t2.join();

    return 0;
}

在这个示例中：

• std::mutex 用于保护对队列数据的并发访问。
• std::lock_guard
• Mutex :

🎜std::mutex est utilisé Protéger les concurrents accès aux données de la file d'attente. 🎜🎜std::lock_guard est utilisé pour verrouiller le mutex lors de l'entrée dans la partie critique de la file d'attente et le déverrouiller lors de sa sortie. 🎜🎜Plusieurs threads peuvent transférer et placer simultanément des données dans la file d'attente en toute sécurité. 🎜🎜🎜Conclusion🎜🎜 La mise en œuvre de structures de données concurrentes thread-safe est un aspect crucial de la programmation simultanée en C++. En utilisant des mécanismes tels que les types atomiques et les verrous mutex, nous pouvons garantir la cohérence des données et empêcher la corruption des données ou les plantages de programmes causés par un accès simultané. 🎜

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!