QWaitCondition Class

forever {
    mutex.lock();
    keyPressed.wait(&mutex);
    do_something();
    mutex.unlock();
}

forever {
    getchar();
    keyPressed.wakeAll();
}

forever {
    mutex.lock();
    keyPressed.wait(&mutex);
    ++count;
    mutex.unlock();

    do_something();

    mutex.lock();
    --count;
    mutex.unlock();
}

forever {
    getchar();

    mutex.lock();
    // Sleep until there are no busy worker threads
    while (count > 0) {
        mutex.unlock();
        sleep(1);
        mutex.lock();
    }
    keyPressed.wakeAll();
    mutex.unlock();
}

Documentation des fonctions membres

QWaitCondition::QWaitCondition()

Construit un nouvel objet de condition d'attente.

[noexcept] QWaitCondition::~QWaitCondition()

Détruit l'objet condition d'attente.

void QWaitCondition::notify_all()

Cette fonction est fournie pour la compatibilité STL. Elle est équivalente à wakeAll().

void QWaitCondition::notify_one()

Cette fonction est fournie pour la compatibilité STL. Elle est équivalente à wakeOne().

bool QWaitCondition::wait(QMutex *lockedMutex, QDeadlineTimer deadline = QDeadlineTimer(QDeadlineTimer::Forever))

Libère le site lockedMutex et attend la condition d'attente. Le lockedMutex doit être initialement verrouillé par le thread appelant. Si lockedMutex n'est pas dans un état verrouillé, le comportement est indéfini. Si lockedMutex est un mutex récursif, cette fonction revient immédiatement. L'adresse lockedMutex sera déverrouillée et le thread appelant bloquera jusqu'à ce que l'une ou l'autre de ces conditions soit remplie :

• Un autre thread le signale en utilisant wakeOne() ou wakeAll(). Dans ce cas, cette fonction renverra true.
• le délai indiqué par deadline est atteint. Si deadline est QDeadlineTimer::Forever (par défaut), le délai d'attente ne sera jamais dépassé (l'événement doit être signalé). Cette fonction renverra false si le délai d'attente a expiré.

L'adresse lockedMutex sera remise dans le même état de verrouillage. Cette fonction est fournie pour permettre la transition atomique de l'état verrouillé à l'état d'attente.

Voir également wakeOne() et wakeAll().

bool QWaitCondition::wait(QReadWriteLock *lockedReadWriteLock, QDeadlineTimer deadline = QDeadlineTimer(QDeadlineTimer::Forever))

Libère le site lockedReadWriteLock et attend la condition d'attente. Le lockedReadWriteLock doit être initialement verrouillé par le thread appelant. Si lockedReadWriteLock n'est pas dans un état verrouillé, cette fonction retourne immédiatement. L'adresse lockedReadWriteLock ne doit pas être verrouillée de manière récursive, sinon cette fonction ne libérera pas le verrou correctement. L'adresse lockedReadWriteLock sera déverrouillée et le thread appelant se bloquera jusqu'à ce que l'une ou l'autre de ces conditions soit remplie :

• Un autre thread le signale en utilisant wakeOne() ou wakeAll(). Dans ce cas, cette fonction renverra true.
• le délai indiqué par deadline est atteint. Si deadline est QDeadlineTimer::Forever (par défaut), le délai d'attente ne sera jamais dépassé (l'événement doit être signalé). Cette fonction renverra false si le délai d'attente a expiré.

L'adresse lockedReadWriteLock sera remise dans le même état de verrouillage. Cette fonction est fournie pour permettre la transition atomique de l'état verrouillé à l'état d'attente.

Voir également wakeOne() et wakeAll().

bool QWaitCondition::wait(QMutex *lockedMutex, unsigned long time)

Libère le site lockedMutex et attend la condition d'attente pendant time millisecondes.

bool QWaitCondition::wait(QReadWriteLock *lockedReadWriteLock, unsigned long time)

Libère le site lockedReadWriteLock et attend la condition d'attente pendant time millisecondes.

void QWaitCondition::wakeAll()

Réveille tous les threads en attente de la condition d'attente. L'ordre dans lequel les threads sont réveillés dépend de la politique d'ordonnancement du système d'exploitation et ne peut être contrôlé ou prédit.

Voir également wakeOne().

void QWaitCondition::wakeOne()

Réveille un thread en attente de la condition d'attente. Le thread réveillé dépend de la politique d'ordonnancement du système d'exploitation et ne peut être ni contrôlé ni prédit.

Si vous souhaitez réveiller un thread spécifique, la solution consiste généralement à utiliser différentes conditions d'attente et à faire en sorte que différents threads attendent en fonction de différentes conditions.

Voir également wakeAll().