Comment puis-je implémenter des sémaphores en C 0x sans utiliser Boost ?

Synchronisation en C 0x sans sémaphores

C 0x introduit des variables et des conditions atomiques, mais ne prend pas en charge explicitement les sémaphores. Cela a soulevé des inquiétudes quant à la façon de synchroniser efficacement les threads sans utiliser l'implémentation du sémaphore de Boost.

Une méthode consiste à utiliser une combinaison de mutex et de variables de condition pour créer un sémaphore personnalisé. Prenons l'exemple suivant :

#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 implémentation utilise un mutex (mutex_) pour protéger l'accès aux données internes et utilise une variable de condition (condition_) pour signaler les threads en attente lorsqu'un sémaphore est libéré. La variable count_ member est initialisée à zéro, indiquant un état initialement verrouillé.

Pour libérer un sémaphore (c'est-à-dire le rendre disponible pour l'acquisition), la méthode release() incrémente le nombre et notifie tous les threads en attente. Pour acquérir un sémaphore, la méthode acquire() attend que le décompte soit différent de zéro. La méthode try_acquire() tente d'acquérir le sémaphore de manière non bloquante, renvoyant vrai en cas de succès ou faux dans le cas contraire.

Cette approche fournit un moyen simple et efficace d'implémenter des sémaphores en C 0x sans utiliser Boost. Ses fonctionnalités sont similaires aux sémaphores POSIX, permettant aux threads de synchroniser leur exécution et de communiquer efficacement les événements.

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!