Compétences en programmation multithread en C++

Avec l'amélioration continue du matériel informatique, de plus en plus de logiciels commencent à utiliser la technologie multi-thread pour améliorer les performances des programmes et la vitesse de réponse. Le langage C++ est un langage qui prend en charge la programmation multithread. Cet article présentera quelques techniques de programmation multithread en C++.

1. Comprendre le concept de multi-threading

Avant de faire de la programmation multi-thread, nous devons comprendre ce que sont les threads. Un thread est la plus petite unité d'exécution d'un programme. Il possède son propre compteur de programme, son propre ensemble de registres et sa pile, et partage le segment de code, le segment de données et les ressources du processus. La programmation multithread nous permet d'exécuter plusieurs threads en même temps, et ces threads peuvent s'exécuter simultanément.

2. Utilisez des verrous mutex pour protéger les ressources partagées

Dans la programmation multithread, plusieurs threads peuvent accéder à la même ressource partagée en même temps. Cela peut entraîner une incohérence des données, nous devons donc utiliser un mutex pour protéger les ressources partagées. Un mutex est une primitive de synchronisation qui permet à plusieurs threads de partager la même ressource, mais un seul thread peut accéder à la ressource. La bibliothèque standard C++ fournit la classe std::mutex pour prendre en charge le mécanisme de verrouillage mutex.

Par exemple, nous pouvons utiliser l'extrait de code suivant pour protéger les opérations de lecture et d'écriture d'une variable :

#include <mutex>
#include <iostream>

std::mutex mtx; // 申明一个互斥锁

int main()
{
    int count = 0;
    std::thread t1([&count]() {
        for (int i = 0; i < 1000000; i++) {
            mtx.lock(); // 加锁
            count++;
            mtx.unlock(); // 解锁
        }
    });

    std::thread t2([&count]() {
        for (int i = 0; i < 1000000; i++) {
            mtx.lock(); // 加锁
            count++;
            mtx.unlock(); // 解锁
        }
    });

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

    std::cout << "count: " << count << std::endl;
    return 0;
}

Dans le code ci-dessus, nous protégeons les opérations de lecture et d'écriture de la variable count en créant un objet std::mutex mtx. Utilisez la fonction mtx.lock() pour verrouiller l'objet mtx et empêcher d'autres threads d'accéder à la variable count. L'utilisation de la fonction mtx.unlock() peut déverrouiller l'objet mtx et permettre à d'autres threads d'accéder à la variable count.

3. Utilisez des variables de condition pour attendre et notifier les threads

Dans la programmation multithread, nous devons parfois attendre que certaines conditions soient remplies avant de poursuivre l'exécution. Dans ce cas, vous pouvez utiliser une variable de condition pour attendre et notifier les autres threads.

Les variables de condition sont un mécanisme de synchronisation qui permet aux threads d'attendre des événements spécifiques au lieu d'attendre. Lorsqu'un thread attend une variable de condition, il se met en veille jusqu'à ce qu'un autre thread le notifie via la variable de condition. La bibliothèque standard C++ fournit la classe std::condition_variable pour prendre en charge le mécanisme des variables de condition.

Par exemple, nous pouvons utiliser l'extrait de code suivant pour attendre et notifier les threads :

#include <condition_variable>
#include <mutex>
#include <thread>
#include <iostream>

std::mutex mtx;
std::condition_variable cv;
bool is_ready = false;

void work()
{
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return is_ready; }); // 等待条件变量满足
    std::cout << "Work started!" << std::endl;
}

int main()
{
    std::thread t(work);

    std::this_thread::sleep_for(std::chrono::seconds(2));

    {
        std::lock_guard<std::mutex> lock(mtx);
        is_ready = true;
    }

    cv.notify_one(); // 通知工作线程条件变量
    t.join();
    return 0;
}

Dans le code ci-dessus, nous créons un thread de travail t et utilisons std::unique_locke72b3c73eefdfe1ad5a5ce11c373391e Le thread t attend que la variable de condition soit satisfaite avant de poursuivre l'exécution. Dans le thread principal, nous utilisons std::lock_guarde72b3c73eefdfe1ad5a5ce11c373391e pour verrouiller le mutex et modifier la valeur de la variable is_ready, puis informer le thread que la variable de condition t a été satisfaite via cv.notify_one().

4. Utilisez std::atomic pour garantir les opérations atomiques

Dans la programmation multithread, plusieurs threads modifient généralement la même variable en même temps. Dans ce cas, nous devons nous assurer que l’opération sur la variable est atomique. La bibliothèque standard C++ fournit le type std::atomic pour prendre en charge les opérations atomiques.

Le type std::atomic peut garantir que l'opération est atomique, c'est-à-dire qu'il garantit qu'un ensemble d'opérations ne sera en aucun cas interrompu par d'autres threads. Utilisez la classe std::atomic pour éviter les conditions de concurrence et autres problèmes liés au multithread.

Par exemple, nous pouvons utiliser l'extrait de code suivant pour démontrer l'utilisation de std::atomic :

#include <iostream>
#include <atomic>
#include <thread>

std::atomic<int> counter(0); // 申明一个原子性变量

void func()
{
    for (int i = 0; i < 1000000; ++i) {
        counter++; // 自增操作
    }
}

int main()
{
    std::thread t1(func);
    std::thread t2(func);

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

    std::cout << "counter: " << counter << std::endl;
    return 0;
}

Dans le code ci-dessus, nous créons deux threads t1 et t2 et utilisons un compteur de type std::atomic

Résumé

Cet article présente quelques techniques de programmation multithread en C++. L'utilisation de verrous mutex et de variables de condition peut protéger les ressources partagées et implémenter la communication entre threads, tandis que l'utilisation de std::atomic peut garantir les opérations atomiques et éviter les problèmes liés au multithreading. Lorsque vous utilisez une programmation multithread, faites attention à la sécurité et à l'exactitude des threads et assurez-vous que les opérations sur les ressources partagées sont atomiques.

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!