Comment implémenter la sécurité des threads dans la conception de classes C++ ?

Pour assurer la sécurité des threads, il existe deux méthodes en C++ : Utilisez un mutex pour protéger la section critique, en autorisant un seul thread à la fois à y accéder. Grâce aux opérations atomiques, les opérations sont effectuées de manière indivisible, éliminant ainsi les problèmes d'accès simultané.

Implémentation de la sécurité des threads dans la conception de classes C++

Introduction

Dans un environnement multithread, il est crucial d'assurer la sécurité des threads des données. Il existe plusieurs façons d’y parvenir en C++. Cet article explique comment utiliser les mutex et les opérations atomiques pour concevoir des classes thread-safe.

Mutex

Un mutex est un mécanisme de verrouillage qui permet à un seul thread d'accéder à une section critique à la fois. Lorsqu'un thread entre dans la section critique, il acquiert la propriété du mutex. Les autres threads essayant d'entrer dans la section critique se bloqueront jusqu'à ce que le thread libère le mutex.

class ThreadSafeCounter {
private:
    std::mutex m_mutex;
    int m_count;

public:
    void increment() {
        std::lock_guard<std::mutex> lock(m_mutex);
        ++m_count;
    }

    int get() {
        std::lock_guard<std::mutex> lock(m_mutex);
        return m_count;
    }
};

Dans l'exemple ci-dessus, les méthodes increment() et get() utilisent le std::mutex de la bibliothèque standard pour protéger le quartier critique. Pendant qu'un thread met à jour le décompte, les autres threads ne peuvent pas entrer dans la méthode increment() en même temps. increment() 和 get() 方法都使用标准库中的 std::mutex 保护临界区。当一个线程正在更新计数时，其他线程无法同时进入 increment() 方法。

原子操作

原子操作是一种特殊类型的操作，它以不可分割的方式执行。这意味着一次只能在单个线程中执行这些操作，从而消除了并发访问引发的问题。C++11 中引入了 std::atomic 库，它提供了用于原子操作的类。

class ThreadSafeCounterAtomic {
private:
    std::atomic<int> m_count;

public:
    void increment() {
        ++m_count;
    }

    int get() {
        return m_count.load();
    }
};

在本例中，m_count 是一个原子整数，可以安全地从多个线程中进行增量和获取。std::atomic<int>::load()

Opérations atomiques

Les opérations atomiques sont un type spécial d'opérations qui sont effectuées de manière indivisible. Cela signifie que ces opérations ne peuvent être effectuées que dans un seul thread à la fois, éliminant ainsi les problèmes causés par les accès simultanés. C++11 a introduit la bibliothèque std::atomic, qui fournit des classes pour les opérations atomiques.

#include <thread>

int main() {
    std::unique_ptr<ThreadSafeCounter> counter = std::make_unique<ThreadSafeCounter>();

    std::vector<std::thread> threads(10);
    for (auto& thread : threads) {
        thread = std::thread([&] {
            for (int i = 0; i < 1000000; ++i) {
                counter->increment();
            }
        });
    }

    for (auto& thread : threads) {
        thread.join();
    }

    std::cout << "最终计数：" << counter->get() << std::endl;
}

Dans ce cas, m_count est un entier atomique qui peut être incrémenté et récupéré en toute sécurité à partir de plusieurs threads. La méthode std::atomic<int>::load() obtient la valeur d'un entier atomique de manière thread-safe.

Cas pratique

Prenons un exemple de compteur partagé qui doit être mis à jour en parallèle à partir de plusieurs threads :

rrreee

Dans ce programme, nous mettons à jour le compteur en parallèle à partir de 10 threads puis imprimons le décompte final dans le fil conducteur. Le mutex garantit que le compteur ne peut être mis à jour que par un seul thread à la fois, garantissant ainsi la sécurité des threads. 🎜🎜🎜Conclusion🎜🎜🎜Les classes C++ thread-safe peuvent être conçues en utilisant des mutex et des opérations atomiques. Les mutex conviennent à la protection des sections critiques nécessitant un accès série, tandis que les opérations atomiques conviennent aux opérations qui ne nécessitent pas d'accès série et peuvent être effectuées de manière atomique. 🎜

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!