Implémentation de l'exclusion mutuelle et de la section critique des fonctions C++ en programmation concurrente ?

En programmation simultanée, les mutex et les sections critiques sont utilisés pour empêcher les courses de données. Mutex est une structure de données qui permet à un seul thread d'accéder à une ressource partagée à la fois. L'implémentation spécifique est la suivante : Définissez une classe Mutex avec une balise atomique. Utilisez la méthode test_and_set() pour verrouiller et la méthode clear() pour déverrouiller. La section critique est une section de code qui ne peut être exécutée que par un seul thread à la fois. L'implémentation spécifique est la suivante : déclarer un mutex. Utilisez le wrapper lock_guard pour accéder aux ressources partagées dans les sections critiques.

Implémentation de la fonction C++ de l'exclusion mutuelle et de la section critique dans la programmation simultanée

Dans la programmation simultanée, lorsque plusieurs threads accèdent à des ressources partagées en même temps, il est nécessaire d'empêcher la concurrence des données et d'assurer la cohérence des données. Les mutex et les sections critiques sont deux moyens courants d'y parvenir.

Exclusion mutuelle

Mutex est une structure de données qui garantit qu'un seul thread peut accéder à une ressource partagée à la fois. Les mutex sont généralement implémentés à l'aide des méthodes suivantes :

class Mutex {
private:
    std::atomic_flag flag;

public:
    void lock() {
        while (flag.test_and_set(std::memory_order_acquire));
    }

    void unlock() {
        flag.clear(std::memory_order_release);
    }
};

Section critique

Une section critique est une section de code qu'un seul thread peut exécuter à un moment donné. Les sections critiques sont généralement implémentées en utilisant la syntaxe suivante :

std::mutex mutex;

void critical_section() {
    std::lock_guard<std::mutex> lock(mutex);
    // 共享资源的访问
}

Un exemple pratique

Considérons un programme qui contient un compteur partagé que plusieurs threads peuvent incrémenter simultanément. Protégez le compteur à l'aide d'un mutex :

Mutex counter_mutex;
int counter = 0;

void increment_counter() {
    counter_mutex.lock();
    counter++;
    counter_mutex.unlock();
}

Protégez le compteur à l'aide d'une section critique :

std::mutex counter_mutex;

void increment_counter() {
    std::lock_guard<std::mutex> lock(counter_mutex);
    counter++;
}

L'utilisation d'un mutex ou d'une section critique peut garantir qu'un seul thread modifie le compteur en même temps, évitant ainsi les courses de données. Le bon choix dépend des exigences de performances et de complexité de votre application spécifique.

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!