Les sémaphores C 0x peuvent-ils être émulés à l'aide de mutex et de variables de condition ?

Pouvez-vous utiliser des sémaphores en C 0x ?

La synchronisation basée sur les sémaphores est essentielle pour la communication par thread. En l'absence de sémaphores en C 0x, cela ressemble à une impasse.

Émulation de sémaphore avec mutex et variables de condition

Heureusement, un sémaphore peut être recréé à l'aide d'un mutex et une variable de condition. Voici une implémentation simple :

#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;
    }
};

Cette émulation fournit les comportements fondamentaux des sémaphores :

• release() signale un événement qui peut être en attente sur le sémaphore.
• acquire() attend un signal avant de poursuivre l'exécution.
• try_acquire() vérifie et récupère un permis si disponible, sans blocage.

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!