Warten auf mehrere Zustandsvariablen in Boost?

Ich glaube nicht, dass Sie alles tun können, wie dies mit boost::thread. Vielleicht, weil POSIX-bedingungsvariablen erlauben nicht diese Art von konstruieren. Natürlich hat Windows WaitForMultipleObjects aJ gebucht, die Lösung sein könnte, wenn Sie bereit sind, Schränken Sie Ihren code, um Windows synchronization primitives.

Eine weitere Möglichkeit wäre, weniger condition-Variablen: habe nur 1 condition variable, auf die Sie feuern, wenn etwas "Interessantes" passiert. Dann, jedes mal, wenn Sie warten wollen, führen Sie eine Schleife, die überprüft, um zu sehen, ob Ihre spezielle situation, der Interesse hat zu kommen, und wenn nicht, gehen Sie zurück zu, wartet auf die condition variable. Sie warten sollte, auf die Bedingung Variablen, die in einer solchen Schleife sowieso, als bedingungsvariable wartet, unterliegen spurious wakeups (von boost::thread docs, Hervorhebung von mir):

void wait(boost::unique_lock<boost::mutex>& lock)

...

Auswirkungen:

Atomar nennen lock.unlock() und blockiert den aktuellen thread. Der thread öffnest, wenn eine Mitteilung durch einen Anruf zu this->notify_one() oder this->notify_all() oder spuriously. ...

InformationsquelleAutor der Antwort Managu

alternative solutions?

Ich bin nicht sicher, ob der Boost-Bibliothek, aber Sie können WaitForMultipleObjects Funktion zu warten für mehrere kernel-Objekte. Überprüfen Sie einfach, ob das hilft.

InformationsquelleAutor der Antwort aJ.

Unter Verwendung der gleichen Bedingung variable für mehrere Veranstaltungen technisch funktioniert, aber es funktioniert nicht erlauben die Kapselung. Also ich hatte den Versuch zu machen, eine Klasse, die es unterstützt. Noch nicht getestet! Es auch nicht unterstützen notify_one() als ich noch nicht so geklappt hat, wie zu implementieren.

#pragma once

#include <condition_variable>
#include <unordered_set>

//This is like a `condition_variable` but you can wait on multiple `multi_condition_variable`s.
//Internally it works by creating a new `condition_variable` for each `wait_any()` and registering
//it with the target `multi_condition_variable`s. When `notify_all()` is called, the main `condition_variable`
//is notified, as well as all the temporary `condition_variable`s created by `wait_any()`.
//
//There are two caveats:
//
// 1. You can't call the destructor if any threads are `wait()`ing. This is difficult to get around but
//    it is the same as `std::wait_condition` anyway.
//
// 2. There is no `notify_one()`. You can *almost* implement this, but the only way I could think to do
//    it was to add an `atomic_int` that indicates the number of waits(). Unfortunately there is no way
//    to atomically increment it, and then wait.
class multi_condition_variable
{
public:
    multi_condition_variable()
    {
    }

    //Note that it is only safe to invoke the destructor if no thread is waiting on this condition variable.
    ~multi_condition_variable()
    {
    }

    //Notify all threads calling wait(), and all wait_any()'s that contain this instance.
    void notify_all()
    {
        _condition.notify_all();
        for (auto o : _others)
            o->notify_all();
    }

    //Wait for notify_all to be called, or a spurious wake-up.
    void wait(std::unique_lock<std::mutex>& loc)
    {
        _condition.wait(loc);
    }

    //Wait for any of the notify_all()'s in `cvs` to be called, or a spurious wakeup.
    static void wait_any(std::unique_lock<std::mutex>& loc, std::vector<std::reference_wrapper<multi_condition_variable>> cvs)
    {
        std::condition_variable c;
        for (multi_condition_variable& cv : cvs)
            cv.addOther(&c);
        c.wait(loc);
        for (multi_condition_variable& cv : cvs)
            cv.removeOther(&c);
    }

private:
    void addOther(std::condition_variable* cv)
    {
        std::lock_guard<std::mutex> lock(_othersMutex);
        _others.insert(cv);
    }

    void removeOther(std::condition_variable* cv)
    {
        //Note that *this may have been destroyed at this point.
        std::lock_guard<std::mutex> lock(_othersMutex);
        _others.erase(cv);
    }

    //The condition variable.
    std::condition_variable _condition;

    //When notified, also notify these.
    std::unordered_set<std::condition_variable*> _others;

    //Mutex to protect access to _others.
    std::mutex _othersMutex;
};

//Example use:
//
// multi_condition_variable cond1;
// multi_condition_variable cond2;
//
// void wait_for_data_to_process()
// {
//     unique_lock<boost::mutex> lock(mut);
//
//     multi_condition_variable::wait_any(lock, {cond1, cond2});
//
//     process_data();
// }

InformationsquelleAutor der Antwort Timmmm