d'attente pour de multiples variables de condition de suralimentation?

Je suis à la recherche d'un moyen d'attendre pour de multiples variables de condition.
c'est à dire. quelque chose comme:

boost::condition_variable cond1;  
boost::condition_variable cond2;

void wait_for_data_to_process()  
{  
    boost::unique_lock<boost::mutex> lock(mut);

    wait_any(lock, cond1, cond2); //boost only provides cond1.wait(lock);

    process_data();
}

Est quelque chose comme cela possible avec les variables de condition. Et si non existe t il d'autres solutions?

Grâce

InformationsquelleAutor | 2009-09-11

boost c++multithreading

11

Je ne crois pas que vous pouvez faire quelque chose comme ça avec boost::thread. Peut-être parce que POSIX variables de condition, de ne pas autoriser ce type de construction. Bien sûr, Windows a WaitForMultipleObjects comme aJ posté, ce qui pourrait être une solution si vous êtes prêt à limiter votre code pour Windows primitives de synchronisation.

Une autre option serait d'utiliser moins de variables de condition: avoir juste 1 de la variable de condition que vous le feu, quand quelque chose "d'intéressant" arrive. Ensuite, chaque fois que vous voulez attendre, vous exécutez une boucle qui vérifie si votre situation particulière de l'intérêt a venir, et si non, retournez à l'attente sur la variable de condition. Vous devriez être en attente sur ces variables de condition dans une boucle de ce genre de toute façon, en tant que variable de condition les temps d'attente sont soumis à des parasites de réveils (à partir de boost::thread docs, c'est moi qui souligne):

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

...

Effets:

Atomiquement appel lock.unlock() et bloque le thread courant. Le fil se débloquer lorsque informé par un appel à this->notify_one() ou this->notify_all(), ou erreur. ...
- Il me semble que le fait d'avoir une troisième variable de condition pour "1 ou 2 modifié" est en effet la meilleure approche. Une autre approche consiste à convertir attendre à condition d'en attendre sur les descripteurs de fichiers à l'aide de sélectionner et utiliser des tuyaux pour pour le fil de la communication. Depuis que cette question est générique (il n'explique pas ce que les choses sont attendu sur), il n'est pas clair qui sera mieux.
- Le problème avec l'aide d'une variable de condition est l'encapsulation. Vous ne pouvez pas avoir toutes les fonctions comme GoStyleChannel::receive_but_break_if(condition_variable& cv, function& pred). En d'autres termes, supposons que vous avez un certain blocage de la fonction qui utilise une variable de condition. Vous souhaitez bloquer jusqu'à ce que la condition qui se produit ou votre condition se produit. Vous ne pouvez pas le faire sans avoir un mondial std::condition_variable somethingHasHappenedSomewhere, qui est vraiment de la merde.
InformationsquelleAutor Managu

Comme Managu déjà répondu, vous pouvez utiliser la même variable de condition et de vérifier plusieurs "événements" (bool variables) dans ta boucle while. Toutefois, l'accès simultané à ces bool variables doivent être protégées à l'aide de la même mutex que le condvar utilise.

Depuis que je suis déjà passé par la peine de taper ce code exemple pour une question, je vais reposter ici:

boost::condition_variable condvar;
boost::mutex mutex;
bool finished1 = false;
bool finished2 = false;

void longComputation1()
{
    {
        boost::lock_guard<boost::mutex> lock(mutex);
        finished1 = false;
    }
    //Perform long computation
    {
        boost::lock_guard<boost::mutex> lock(mutex);
        finished1 = true;
    }
    condvar.notify_one();
}

void longComputation2()
{
    {
        boost::lock_guard<boost::mutex> lock(mutex);
        finished2 = false;
    }
    //Perform long computation
    {
        boost::lock_guard<boost::mutex> lock(mutex);
        finished2 = true;
    }
    condvar.notify_one();
}

void somefunction()
{
    //Wait for long computations to finish without "spinning"
    boost::lock_guard<boost::mutex> lock(mutex);
    while(!finished1 && !finished2)
    {
        condvar.wait(lock);
    }

    //Computations are finished
}

+1 c'est une bonne solution

InformationsquelleAutor Emile Cormier

0
```
alternative solutions?
```
Je ne suis pas sûr de la bibliothèque Boost, mais vous pouvez utiliser WaitForMultipleObjects Fonction d'attendre plusieurs objets du noyau. Il suffit de vérifier si cela aide.
- Oui, je sais, de WaitForMultipleObject. Je suis à la recherche de l'équivalent en boost. Mais il semble que le boost de ne pas en fournir un. Voir: lists.boost.org/Archives/boost/2004/12/77175.php
InformationsquelleAutor aJ.
0

Comme Managu points à l'aide de plusieurs conditions peuvent ne pas être une bonne solution en premier lieu. Ce que vous voulez faire devrait être possible pour être mis en œuvre à l'aide de Sémaphores.

InformationsquelleAutor count0

En utilisant la même variable de condition pour plusieurs événements techniquement fonctionne, mais il ne permet pas d'encapsulation. J'ai donc eu une tentative de faire une classe qui prend en charge. Pas encore testé! Aussi, il ne prend pas en charge notify_one() que je n'ai pas travaillé sur la façon de l'appliquer.

#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 Timmmm

Vous devez vous connecter pour publier un commentaire.