Comment effectuer une programmation simultanée en code C++ ?

Comment effectuer une programmation simultanée en code C++ ?

Avec le développement de la technologie informatique, l'application de processeurs multicœurs et de calcul parallèle devient de plus en plus courante. Pour les développeurs de programmes, la manière d'utiliser les capacités de calcul parallèle des processeurs multicœurs pour améliorer les performances des programmes est devenue un sujet important. En tant que langage de programmation puissant, C++ fournit une multitude d'outils et de bibliothèques pour la programmation simultanée. Cet article explique comment effectuer une programmation simultanée dans du code C++.

1. Threads et processus

En C++, les threads et les processus peuvent être utilisés pour implémenter la programmation simultanée. Un thread est l'unité d'exécution d'un programme et plusieurs threads peuvent s'exécuter en parallèle, tandis qu'un processus est une instance d'un programme et différents processus peuvent s'exécuter en parallèle. Le calcul parallèle peut être réalisé en créant plusieurs threads ou processus.

C++ fournit une prise en charge multi-thread et vous pouvez utiliser la classe std::thread pour créer et gérer des threads. Voici un exemple simple :

#include <iostream>
#include <thread>

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

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

Dans cet exemple, nous créons un thread nommé t puis appelons sa fonction join() pour attendre que le thread termine son exécution. Dans cet exemple, la fonction de thread hello() génère un message.

2. Verrouillage mutex

En programmation simultanée, lorsque plusieurs threads accèdent à des ressources partagées en même temps, cela peut entraîner une concurrence entre les données et un comportement incertain. Pour éviter cette situation, vous pouvez utiliser un mutex pour protéger les ressources partagées. C++ fournit la classe std::mutex pour implémenter les verrous mutex.

Voici un exemple d'utilisation d'un mutex :

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

std::mutex mtx;

void count() {
    std::lock_guard<std::mutex> lock(mtx);
    for (int i = 0; i < 10; ++i) {
        std::cout << i << std::endl;
    }
}

int main() {
    std::thread t1(count);
    std::thread t2(count);
    t1.join();
    t2.join();
    return 0;
}

Dans cet exemple, nous créons deux threads t1 et t2, qui accèdent à un compteur de boucles en même temps. Afin d'assurer la sécurité des accès concurrents, nous utilisons un verrou mutex mtx. La classe std::lock_guard est une classe RAII (acquisition de ressources, c'est-à-dire initialisation) utilisée pour libérer automatiquement les verrous.

3. Variables de condition

En programmation simultanée, la communication et la synchronisation entre les threads sont parfois nécessaires. C++ fournit des variables de condition (condition_variable) pour implémenter l'attente et le réveil des threads.

Ce qui suit est un exemple d'utilisation de variables de condition :

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

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

void worker() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return ready; });
    std::cout << "Worker thread is running!" << std::endl;
}

int main() {
    std::thread t(worker);
    std::this_thread::sleep_for(std::chrono::seconds(2));
    
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_one();
    
    t.join();
    return 0;
}

Dans cet exemple, nous créons un thread t qui attend que la valeur de la variable prête soit vraie. Dans le thread principal, nous attendons 2 secondes, définissons prêt sur true et informons le thread t via la fonction notify_one() de la variable de condition cv.

4. Conteneurs simultanés

C++ fournit des classes de conteneurs simultanées, telles que std::list, std::queue, std::map, etc., qui sont utilisées pour accéder et modifier en toute sécurité des éléments du conteneur dans plusieurs threads. .

Voici un exemple d'utilisation de la file d'attente simultanée std::queue:

#include <iostream>
#include <thread>
#include <queue>

std::queue<int> q;
std::mutex mtx;

void producer() {
    for (int i = 0; i < 10; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        q.push(i);
    }
}

void consumer() {
    while (true) {
        std::lock_guard<std::mutex> lock(mtx);
        if (!q.empty()) {
            int value = q.front();
            q.pop();
            std::cout << "Consumed: " << value << std::endl;
        }
        else {
            break;
        }
    }
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join();
    t2.join();
    return 0;
}

Dans cet exemple, nous créons un thread producteur et un thread consommateur. Le thread producteur ajoute des éléments à la file d'attente et le thread consommateur extrait les éléments de la file d'attente pour les consommer. Afin d'assurer la sécurité des accès concurrents, nous utilisons le mutex mtx.

Résumé :

Grâce à la programmation simultanée de threads et de processus, vous pouvez utiliser pleinement les capacités de calcul parallèle des processeurs multicœurs et améliorer les performances du programme. C++ fournit une multitude d'outils et de bibliothèques, tels que std::thread, std::mutex, std::condition_variable et des conteneurs simultanés, pour implémenter la programmation simultanée. Lors de l'exécution d'une programmation simultanée, vous devez faire attention aux problèmes de concurrence et de synchronisation des données pour éviter l'apparition de comportements incertains. Dans les applications pratiques, le choix d'une solution de programmation simultanée appropriée en fonction de besoins spécifiques peut améliorer encore les performances du programme.

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!