Comment puis-je réaliser quelque chose de similaire à un sémaphore en utilisant Boost en C ++?

C'est une façon de mettre en œuvre un sémaphore très simple en utilisant Boost.thread. C'est un sémaphore inter-thread, pas une interprocession. Aucune garantie implicite, etc. - Je n'ai même pas compilé le code. Il illustre la manière dont les mutiles et les variables de condition interagissent et suppose une version raisonnablement récente de Boost.

remarquez comment la variable Mutex et la variable de condition sont "jumelées" - Les threads doivent avoir une serrure sur le mutex pour attendre la variable de condition et ré-acquérir la serrure quand elles sont réveillées. En outre, le code qui modifie les données nécessaires pour réveiller explicitement un autre code qui pourrait être attendu. Cela signifie que le mutex, la variable de condition, les données et la ou les conditions qui entraînent le réveil, sont toutes étroitement couplées. Le couplage serré signifie également que les données, le mutex et la variable de condition doivent être encapsulées si possible si possible - toute modification externe peut casser le code de manière étrange, y compris des blocages, des réveils manqués et d'autres bugs étranges. P>

Tous Ceci est vraiment destiné à compléter la réponse de Vlad Lazarenko - Comprendre la théorie et les principes sont au moins aussi importants que de "travailler", dans la programmation multi-threadé. P>

#include <boost/thread/condition_variable.hpp>
#include <boost/thread/mutex.hpp>    
#include <boost/thread/lock_types.hpp>


class semaphore
{
    //The current semaphore count.
    unsigned int count_;

    //mutex_ protects count_.
    //Any code that reads or writes the count_ data must hold a lock on
    //the mutex.
    boost::mutex mutex_;

    //Code that increments count_ must notify the condition variable.
    boost::condition_variable condition_;

public:
    explicit semaphore(unsigned int initial_count) 
       : count_(initial_count),
         mutex_(), 
         condition_()
    {
    }

    unsigned int get_count() //for debugging/testing only
    {
        //The "lock" object locks the mutex when it's constructed,
        //and unlocks it when it's destroyed.
        boost::unique_lock<boost::mutex> lock(mutex_);
        return count_;
    }

    void signal() //called "release" in Java
    {
        boost::unique_lock<boost::mutex> lock(mutex_);

        ++count_;

        //Wake up any waiting threads. 
        //Always do this, even if count_ wasn't 0 on entry. 
        //Otherwise, we might not wake up enough waiting threads if we 
        //get a number of signal() calls in a row.
        condition_.notify_one(); 
    }

    void wait() //called "acquire" in Java
    {
        boost::unique_lock<boost::mutex> lock(mutex_);
        while (count_ == 0)
        {
             condition_.wait(lock);
        }
        --count_;
    }

};

J'ai fait une classe de sémaphore compatible avec des boosts TimedLockable concept, de sorte qu'il peut être utilisé avec des verrous comme boost :: unique_lock . Ce n'est pas un sémaphore dans une définition classique d'un, mais peut être utilisé comme un. Néanmoins, j'espère que cela peut être utile pour quelqu'un.

Son en quelque sorte testé, mais il y a une grande possibilité que j'ai fait quelque chose de mal. Serait génial si quelqu'un pouvait prouver l'exactitude. xxx