C ++ 0x n'a pas de sémaphores? Comment synchroniser les threads?

Est-il vrai que C ++ 0x viendra sans sémaphores? Il y a déjà quelques questions sur Stack Overflow concernant l'utilisation des sémaphores. Je les utilise (sémaphores posix) tout le temps pour laisser un thread attendre un événement dans un autre thread:

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

  event1.wait();

  ...
}

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

  event1.post();

  ...
}

Si je faisais ça avec un mutex:

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

  event1.lock(); event1.unlock();

  ...
}

void thread1(...)
{
  event1.lock();

  doSomethingth1();

  event1.unlock();

  ...
}

Problème: C'est moche et il n'est pas garanti que thread1 verrouille le mutex en premier (étant donné que le même thread doit verrouiller et déverrouiller un mutex, vous ne pouvez pas non plus verrouiller event1 avant que thread0 et thread1 ne démarrent).

Donc, puisque boost n'a pas non plus de sémaphores, quel est le moyen le plus simple d'y parvenir?

Vous pouvez facilement en créer un à partir d'un mutex et d'une variable de condition:

#include <mutex>
#include <condition_variable>

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

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

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

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

Sur la base de la réponse de Maxim Yegorushkin , j'ai essayé de créer l'exemple en style C ++ 11.

#include <mutex>
#include <condition_variable>

class Semaphore {
public:
    Semaphore (int count_ = 0)
        : count(count_) {}

    inline void notify()
    {
        std::unique_lock<std::mutex> lock(mtx);
        count++;
        cv.notify_one();
    }

    inline void wait()
    {
        std::unique_lock<std::mutex> lock(mtx);

        while(count == 0){
            cv.wait(lock);
        }
        count--;
    }

private:
    std::mutex mtx;
    std::condition_variable cv;
    int count;
};

J'ai décidé d'écrire le sémaphore C ++ 11 le plus robuste / générique que je pouvais, dans le style de la norme autant que je le pouvais (notez que using semaphore = ...vous utiliseriez normalement le nom semaphoresimilaire à l'utilisation normale de stringnot basic_string):

template <typename Mutex, typename CondVar>
class basic_semaphore {
public:
    using native_handle_type = typename CondVar::native_handle_type;

    explicit basic_semaphore(size_t count = 0);
    basic_semaphore(const basic_semaphore&) = delete;
    basic_semaphore(basic_semaphore&&) = delete;
    basic_semaphore& operator=(const basic_semaphore&) = delete;
    basic_semaphore& operator=(basic_semaphore&&) = delete;

    void notify();
    void wait();
    bool try_wait();
    template<class Rep, class Period>
    bool wait_for(const std::chrono::duration<Rep, Period>& d);
    template<class Clock, class Duration>
    bool wait_until(const std::chrono::time_point<Clock, Duration>& t);

    native_handle_type native_handle();

private:
    Mutex   mMutex;
    CondVar mCv;
    size_t  mCount;
};

using semaphore = basic_semaphore<std::mutex, std::condition_variable>;

template <typename Mutex, typename CondVar>
basic_semaphore<Mutex, CondVar>::basic_semaphore(size_t count)
    : mCount{count}
{}

template <typename Mutex, typename CondVar>
void basic_semaphore<Mutex, CondVar>::notify() {
    std::lock_guard<Mutex> lock{mMutex};
    ++mCount;
    mCv.notify_one();
}

template <typename Mutex, typename CondVar>
void basic_semaphore<Mutex, CondVar>::wait() {
    std::unique_lock<Mutex> lock{mMutex};
    mCv.wait(lock, [&]{ return mCount > 0; });
    --mCount;
}

template <typename Mutex, typename CondVar>
bool basic_semaphore<Mutex, CondVar>::try_wait() {
    std::lock_guard<Mutex> lock{mMutex};

    if (mCount > 0) {
        --mCount;
        return true;
    }

    return false;
}

template <typename Mutex, typename CondVar>
template<class Rep, class Period>
bool basic_semaphore<Mutex, CondVar>::wait_for(const std::chrono::duration<Rep, Period>& d) {
    std::unique_lock<Mutex> lock{mMutex};
    auto finished = mCv.wait_for(lock, d, [&]{ return mCount > 0; });

    if (finished)
        --mCount;

    return finished;
}

template <typename Mutex, typename CondVar>
template<class Clock, class Duration>
bool basic_semaphore<Mutex, CondVar>::wait_until(const std::chrono::time_point<Clock, Duration>& t) {
    std::unique_lock<Mutex> lock{mMutex};
    auto finished = mCv.wait_until(lock, t, [&]{ return mCount > 0; });

    if (finished)
        --mCount;

    return finished;
}

template <typename Mutex, typename CondVar>
typename basic_semaphore<Mutex, CondVar>::native_handle_type basic_semaphore<Mutex, CondVar>::native_handle() {
    return mCv.native_handle();
}

en accord avec les sémaphores posix, j'ajouterais

class semaphore
{
    ...
    bool trywait()
    {
        boost::mutex::scoped_lock lock(mutex_);
        if(count_)
        {
            --count_;
            return true;
        }
        else
        {
            return false;
        }
    }
};

Et je préfère de loin utiliser un mécanisme de synchronisation à un niveau d'abstraction pratique, plutôt que de toujours copier-coller une version assemblée en utilisant des opérateurs plus basiques.

Vous pouvez également consulter cpp11-on-multicore - il a une implémentation de sémaphore portable et optimale.

Le référentiel contient également d'autres goodies de threading qui complètent le threading c ++ 11.

Vous pouvez travailler avec des variables mutex et conditionnelles. Vous obtenez un accès exclusif avec le mutex, vérifiez si vous voulez continuer ou si vous devez attendre l'autre extrémité. Si vous avez besoin d'attendre, vous attendez dans une condition. Lorsque l'autre thread détermine que vous pouvez continuer, il signale la condition.

Il y a un court exemple dans la bibliothèque boost :: thread que vous pouvez très probablement simplement copier (les bibliothèques de threads C ++ 0x et boost sont très similaires).

Peut également être utile wrapper de sémaphore RAII dans les threads:

class ScopedSemaphore
{
public:
    explicit ScopedSemaphore(Semaphore& sem) : m_Semaphore(sem) { m_Semaphore.Wait(); }
    ScopedSemaphore(const ScopedSemaphore&) = delete;
    ~ScopedSemaphore() { m_Semaphore.Notify(); }

   ScopedSemaphore& operator=(const ScopedSemaphore&) = delete;

private:
    Semaphore& m_Semaphore;
};

Exemple d'utilisation dans une application multithread:

boost::ptr_vector<std::thread> threads;
Semaphore semaphore;

for (...)
{
    ...
    auto t = new std::thread([..., &semaphore]
    {
        ScopedSemaphore scopedSemaphore(semaphore);
        ...
    }
    );
    threads.push_back(t);
}

for (auto& t : threads)
    t.join();

C ++ 20 aura enfin des sémaphores - std::counting_semaphore<max_count> .

Ceux-ci auront (au moins) les méthodes suivantes:

• acquire() (blocage)
• try_acquire() (non bloquant, retourne immédiatement)
• try_acquire_for() (non bloquant, prend une durée)
• try_acquire_until() (non bloquant, prend un certain temps pour arrêter d'essayer)
• release()

Cela n'est pas encore répertorié sur cppreference, mais vous pouvez lire ces diapositives de présentation CppCon 2019 ou regarder la vidéo . Il y a aussi la proposition officielle P0514R4 , mais je ne suis pas sûr que ce soit la version la plus à jour.

J'ai trouvé que shared_ptr et low_ptr, un long avec une liste, ont fait le travail dont j'avais besoin. Mon problème était que plusieurs clients souhaitaient interagir avec les données internes d'un hôte. En règle générale, l'hôte met à jour les données de lui-même, cependant, si un client le demande, l'hôte doit arrêter la mise à jour jusqu'à ce qu'aucun client n'accède aux données de l'hôte. En même temps, un client peut demander un accès exclusif, de sorte qu'aucun autre client, ni l'hôte, ne puisse modifier ces données d'hôte.

Comment j'ai fait cela, j'ai créé une structure:

struct UpdateLock
{
    typedef std::shared_ptr< UpdateLock > ptr;
};

Chaque client aurait un membre de tel:

UpdateLock::ptr m_myLock;

Ensuite, l'hôte aurait un membre faible_ptr pour l'exclusivité, et une liste de points faibles pour les verrous non exclusifs:

std::weak_ptr< UpdateLock > m_exclusiveLock;
std::list< std::weak_ptr< UpdateLock > > m_locks;

Il existe une fonction pour activer le verrouillage et une autre fonction pour vérifier si l'hôte est verrouillé:

UpdateLock::ptr LockUpdate( bool exclusive );       
bool IsUpdateLocked( bool exclusive ) const;

Je teste les verrous dans LockUpdate, IsUpdateLocked et périodiquement dans la routine de mise à jour de l'hôte. Tester un verrou est aussi simple que de vérifier si le low_ptr a expiré et de supprimer tout expiré de la liste m_locks (je ne le fais que pendant la mise à jour de l'hôte), je peux vérifier si la liste est vide; en même temps, j'obtiens un déverrouillage automatique lorsqu'un client réinitialise le shared_ptr auquel il s'accroche, ce qui se produit également lorsqu'un client est détruit automatiquement.

L'effet global est que, puisque les clients ont rarement besoin d'exclusivité (généralement réservée aux ajouts et aux suppressions uniquement), la plupart du temps une demande à LockUpdate (false), c'est-à-dire non exclusive, réussit tant que (! M_exclusiveLock). Et un LockUpdate (true), une demande d'exclusivité, ne réussit que lorsque (! M_exclusiveLock) et (m_locks.empty ()).

Une file d'attente pourrait être ajoutée pour atténuer les verrous exclusifs et non exclusifs, cependant, je n'ai eu aucune collision jusqu'à présent, donc j'ai l'intention d'attendre que cela se produise pour ajouter la solution (surtout, j'ai donc une condition de test dans le monde réel).

Jusqu'à présent, cela fonctionne bien pour mes besoins; Je peux imaginer la nécessité d'étendre cela, et certains problèmes qui pourraient survenir lors d'une utilisation étendue, cependant, cela a été rapide à implémenter et n'a nécessité que très peu de code personnalisé.

Au cas où quelqu'un serait intéressé par la version atomique, voici l'implémentation. Les performances sont attendues meilleures que la version mutex & condition variable.

class semaphore_atomic
{
public:
    void notify() {
        count_.fetch_add(1, std::memory_order_release);
    }

    void wait() {
        while (true) {
            int count = count_.load(std::memory_order_relaxed);
            if (count > 0) {
                if (count_.compare_exchange_weak(count, count-1, std::memory_order_acq_rel, std::memory_order_relaxed)) {
                    break;
                }
            }
        }
    }

    bool try_wait() {
        int count = count_.load(std::memory_order_relaxed);
        if (count > 0) {
            if (count_.compare_exchange_strong(count, count-1, std::memory_order_acq_rel, std::memory_order_relaxed)) {
                return true;
            }
        }
        return false;
    }
private:
    std::atomic_int count_{0};
};