Implémenter la programmation de threads en utilisant C++

Avec le développement continu de la technologie informatique, les processeurs multicœurs et la programmation multithread sont devenus des technologies de plus en plus importantes et courantes. En tant que langage de programmation orienté objet largement utilisé, le C++ présente des avantages uniques dans la réalisation d’une programmation multithread. Cet article explique comment utiliser C++ pour implémenter la programmation de threads, y compris la création, la synchronisation et l'exclusion mutuelle de threads.

1. Le concept de base des threads

Les threads sont les unités d'exécution de base des processus. Un processus peut contenir plusieurs threads. Les threads ont les caractéristiques suivantes :

(1) Les threads font partie du processus et partagent donc l'espace mémoire du processus.

(2) Les threads peuvent être exécutés simultanément, ce qui améliore l'efficacité d'exécution du programme.

(3) Les données peuvent être partagées entre les threads, mais elles sont également confrontées à des problèmes de concurrence en matière de données.

(4) Les threads ont des processus d'exécution indépendants et peuvent avoir leurs propres piles et registres, etc.

2. Création de threads

C++ fournit une variété de méthodes pour créer des threads, dont la plus couramment utilisée est d'utiliser la classe thread.

(1) Créer un objet thread

Utilisez le constructeur de la classe thread pour créer un objet thread, tel que le code suivant :

#include <iostream>
#include <thread>

void func()
{
    std::cout << "hello from thread" << std::endl;
}

int main()
{
    std::thread t(func);
    t.join();
    return 0;
}

Dans le code ci-dessus, la fonction func est la fonction d'exécution du thread, utilisez std::thread t(func) Créez un objet thread, appelez t.join() dans la fonction principale pour exécuter le thread et attendez que le thread termine son exécution avant de quitter le programme.

(2) Passage de paramètres

Si vous devez transmettre des paramètres dans le thread, vous pouvez transmettre les paramètres lors de la création de l'objet thread, comme le code suivant :

#include <iostream>
#include <thread>

void func(int num)
{
    std::cout << "hello from thread " << num << std::endl;
}

int main()
{
    std::thread t(func, 3);
    t.join();
    return 0;
}

Dans le code ci-dessus, la fonction func a un paramètre de type int num, dans le paramètre Pass 3 lors de la création de l'objet thread.

3. Synchronisation des threads

Lorsque plusieurs threads sont exécutés en même temps, certains problèmes peuvent survenir, tels qu'une concurrence de données, un blocage, etc. Afin d’éviter ces problèmes, le concept de synchronisation des threads doit être introduit.

(1) Mutex

Mutex est l'un des mécanismes de synchronisation de threads les plus couramment utilisés, qui peut empêcher plusieurs threads d'accéder aux ressources partagées en même temps. C++ fournit la classe std::mutex pour implémenter les mutex, comme le code suivant :

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

std::mutex mtx;

void func()
{
    mtx.lock();
    std::cout << "hello from thread" << std::endl;
    mtx.unlock();
}

int main()
{
    std::thread t(func);
    mtx.lock();
    std::cout << "hello from main" << std::endl;
    mtx.unlock();
    t.join();
    return 0;
}

Dans le code ci-dessus, mtx.lock() et mtx.unlock() sont utilisés respectivement pour verrouiller et déverrouiller le mutex. Les mutex sont utilisés à la fois dans la fonction func et dans la fonction main pour verrouiller et déverrouiller les instructions de sortie, ce qui garantit que les instructions de sortie sont exécutées dans l'ordre spécifié.

(2) Variable de condition

La variable de condition est un mécanisme de synchronisation de threads qui peut être utilisé pour attendre qu'une certaine condition soit remplie avant de poursuivre l'exécution. C++ fournit la classe std::condition_variable pour implémenter des variables de condition, comme le code suivant :

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

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

void func1()
{
    std::unique_lock<std::mutex> ul(mtx);
    while(!flag)
    {
        cv.wait(ul);
    }
    std::cout << "hello from thread1" << std::endl;
}

void func2()
{
    std::unique_lock<std::mutex> ul(mtx);
    flag = true;
    cv.notify_one();
}

int main()
{
    std::thread t1(func1);
    std::thread t2(func2);

    t1.join();
    t2.join();
    return 0;
}

Dans le code ci-dessus, cv.wait(ul) est utilisé pour attendre que l'indicateur de variable de condition soit satisfait avant de continuer l'exécution, et cv.notify_one() est utilisé pour notifier les threads en attente de cette variable de condition. Définissez l'indicateur sur true dans la fonction func2 et informez le thread en attente de la réinitialisation de la variable de condition.

4. Résumé

Cet article présente comment utiliser C++ pour implémenter la programmation de threads, y compris la création de threads, la synchronisation et l'exclusion mutuelle. En étudiant cet article, vous apprendrez à utiliser les mécanismes de synchronisation des threads tels que les mutex et les variables de condition pour éviter les problèmes pouvant survenir lorsque plusieurs threads s'exécutent simultanément.

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!