thread en attente jusqu'à ce qu'une condition a été produite

Je veux attendre un thread 2 thread exécuté simultanément simulateur jusqu'à ce qu'une condition a été produite, peut-être la maladie est survenue après 1000 cycles ou plus de l'exécution d'un programme dans le simulateur, après que la condition s'est produite à la attendu thread exécuté à nouveau, comment puis-je le faire?

InformationsquelleAutor Angelia Wikin | 2012-06-11
  1. 32

    Vous avez besoin des variables conditionnelles.

    Si votre compilateur prend en charge std::conditional introduit par le C++11, alors vous pouvez le voir pour les détails:

    Si votre compilateur ne le supporte pas, et vous travaillez avec les threads win32, puis de voir ce:

    Et ici est un exemple complet.

    Et si vous travaillez avec des threads POSIX, alors voir ceci:

    Vous pouvez voir ma mise en œuvre de conditional_variable utilisant win32 primitives ici:

    Faites défiler vers le bas et de voir la mise en oeuvre d'abord, puis de voir l'utilisation de la concurrente de la file d'attente de mise en œuvre.

    Une utilisation typique de la variable de condition est: est-ce

    //lock the mutex first!
scoped_lock myLock(myMutex); 

//wait till a condition is met
myConditionalVariable.wait(myLock, CheckCondition);

//Execute this code only if the condition is met

    oùCheckCondition est une fonction (ou un foncteur) qui vérifie la condition. Il est appelé par wait() fonctionnent à l'intérieur quand il faussement se réveille et si la condition n'a pas encore rencontré le wait() fonction dort encore. Avant d'aller dormir, wait() libère le mutex, atomiquement.

    InformationsquelleAutor Nawaz
  2. 6

    Si vous n'avez pas de C++11, mais que vous avez un système qui prend en charge les threads POSIX, alors vous pouvez utiliser une variable de condition. Il ya d'autres choix, mais une variable de condition peut être le plus simple compte tenu de la façon dont vous avez décrit votre problème.

    Une variable de condition pthread est utilisé en conjonction avec un mutex. Le truc avec la variable de condition est que l'attente sur elle provoque de l'acquis mutex pour être libéré, jusqu'à ce que l'attente retours d'appel, à quel point le mutex a été acquis de nouveau. La séquence est:

    • acquérir mutex
    • tandis que le PRÉDICAT n'est pas vrai
      • attendre sur la variable de condition
    • faire des travaux sur la section critique
    • si le PRÉDICAT est vrai
      • signal variable de condition
    • libération du mutex

    Le signal étape est utilisée dans le cas de plusieurs threads de la saisie de la même section critique ci-dessus.

    Si un autre thread peut accéder à la même mutex pour modifier l'état qui affecte le PRÉDICAT, ce thread devriez vérifier pour voir si quelqu'un a besoin pour être signalé.

    • acquérir mutex
    • faire des travaux sur la section critique
    • si le PRÉDICAT est vrai
      • signal variable de condition
    • libération du mutex

    Les commandes POSIX d'intérêt sont:

    pthread_mutex_init()
pthread_mutex_destroy()
pthread_mutex_lock()
pthread_mutex_unlock()
pthread_cond_init()
pthread_cond_destroy()
pthread_cond_wait()
pthread_cond_signal()
    InformationsquelleAutor jxh
  3. 1

    À l'aide de Sémaphores pour la signalisation. Exemple (demande de nettoyage de sortie) comme ci-dessous:

    Déclarer dans l'en-tête

    static sem_t semPrepareExit;            //declaration

    Dans la source (thread principal);

    sem_init(&semPrepareExit, 0, 0);        ///semaphore initialized
...
///now wait for the signal on the semaphore, to proceed hereforth
sem_post(&semPrepareExit);
///cleanup ahead
...

    Dans la source, (générés-fil);

    ...
sem_post(&semPrepareExit);

    Maintenant, dès que vous le signal sur le sémaphore à l'aide de "sem_post". Le thread va recevoir le signal à l'attente node/point, et va continuer, il y suite.

    InformationsquelleAutor parasrish
  4. 1

    essayer quelque chose comme cela :

    class CmyClass
{
   boost::mutex mtxEventWait;
   bool WaitForEvent(long milliseconds);
   boost::condition cndSignalEvent;
};

bool CmyClass::WaitForEvent(long milliseconds)
{
   boost::mutex::scoped_lock mtxWaitLock(mtxEventWait);
   boost::posix_time::time_duration wait_duration = boost::posix_time::milliseconds(milliseconds); 
   boost::system_time const timeout=boost::get_system_time()+wait_duration; 
   return cndSignalEvent.timed_wait(mtxEventWait,timeout); //wait until signal Event 
}

    //so afinde attendre alors appeler le WaitForEvent méthode

    WaitForEvent(1000); //it will timeout after 1 second

    //c'est comment un événement peut être signalé:

    cndSignalEvent.notify_one();
    InformationsquelleAutor serup