Comment la synchronisation des threads peut-elle être réalisée en C 0x sans utiliser de sémaphores ?

C 0x sans sémaphores : réalisation de la synchronisation des threads

C 0x introduit diverses améliorations, mais une omission notable est l'inclusion de sémaphores. Les sémaphores sont essentiels à la synchronisation des threads, permettant aux threads de signaler les événements et d'attendre leur achèvement.

Énoncé du problème

En l'absence de sémaphores, comment pouvons-nous implémenter un mécanisme pour la synchronisation des threads, comme illustré dans l'utilisation du sémaphore POSIX suivante :

void thread0(...)
{
  doSomething0();

  event1.wait();

  ...
}

void thread1(...)
{
  doSomething1();

  event1.post();

  ...
}

Solution utilisant Mutex et Variable de condition

Une méthode efficace consiste à créer une fonctionnalité de type sémaphore à l'aide d'un mutex et d'une variable de condition. Voici le code :

#include <mutex>
#include <condition_variable>

class semaphore {
    std::mutex mutex_;
    std::condition_variable condition_;
    unsigned long count_ = 0; // Initialized as locked.

public:
    void release() {
        std::lock_guard<decltype(mutex_)> lock(mutex_);
        ++count_;
        condition_.notify_one();
    }

    void acquire() {
        std::unique_lock<decltype(mutex_)> lock(mutex_);
        while(!count_) // Handle spurious wake-ups.
            condition_.wait(lock);
        --count_;
    }

    bool try_acquire() {
        std::lock_guard<decltype(mutex_)> lock(mutex_);
        if(count_) {
            --count_;
            return true;
        }
        return false;
    }
};

Utilisation

Ce sémaphore personnalisé peut être utilisé de la manière suivante :

semaphore event1;

void thread0(...)
{
  doSomething0();

  event1.acquire();

  ...
}

void thread1(...)
{
  doSomething1();

  event1.release();

  ...
}

Comparé vers Mutex uniquement

Cette approche offre plusieurs avantages par rapport à l'utilisation d'un mutex seul :

• Il élimine l'ambiguïté de l'acquisition et de la libération du même mutex dans différents threads, ce qui peut conduire à une impasse.
• Il garantit que le thread1 n'acquiert pas le mutex avant le thread0.
• Il fournit une méthode try_acquire() supplémentaire pour les tentatives d'acquisition non bloquantes.

Par en utilisant cette implémentation de sémaphore personnalisée, vous pouvez réaliser efficacement la synchronisation des threads en C 0x sans prise en charge explicite du sémaphore.

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!