Back to Qt.io
Contact Us Blog Download Qt
Auf dieser Seite

QWaitCondition Class

Die Klasse „QWaitCondition“ stellt eine Bedingungsvariable zur Synchronisierung von Threads bereit. Mehr...

Header: #include <QWaitCondition>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core

Hinweis: Alle Funktionen dieser Klasse sind threadsicher.

Öffentliche Funktionen

QWaitCondition()
~QWaitCondition()
void notify_all()
void notify_one()
bool wait(QMutex *lockedMutex, QDeadlineTimer deadline = QDeadlineTimer(QDeadlineTimer::Forever))
bool wait(QReadWriteLock *lockedReadWriteLock, QDeadlineTimer deadline = QDeadlineTimer(QDeadlineTimer::Forever))
bool wait(QMutex *lockedMutex, unsigned long time)
bool wait(QReadWriteLock *lockedReadWriteLock, unsigned long time)
void wakeAll()
void wakeOne()

Ausführliche Beschreibung

Mit QWaitCondition kann ein Thread anderen Threads mitteilen, dass eine bestimmte Bedingung erfüllt wurde. Ein oder mehrere Threads können blockieren und darauf warten, dass eine QWaitCondition mit ` wakeOne()` oder ` wakeAll()` eine Bedingung setzt. Verwenden Sie ` wakeOne()`, um einen zufällig ausgewählten Thread zu wecken, oder ` wakeAll()`, um alle zu wecken.

Nehmen wir zum Beispiel an, wir hätten drei Aufgaben, die ausgeführt werden sollen, sobald der Benutzer eine Taste drückt. Jede Aufgabe könnte in einen Thread aufgeteilt werden, von denen jeder einen run()-Körper wie diesen hätte:

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

Hier ist die Variable „ keyPressed “ eine globale Variable vom Typ „QWaitCondition“.

Ein vierter Thread würde Tastendrücke lesen und die anderen drei Threads jedes Mal wecken, wenn er einen empfängt, und zwar so:

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

Die Reihenfolge, in der die drei Threads geweckt werden, ist undefiniert. Wenn sich einige der Threads zum Zeitpunkt des Tastendrucks noch in ` do_something() ` befinden, werden sie zudem nicht geweckt (da sie nicht auf die Bedingungsvariable warten), sodass die Aufgabe für diesen Tastendruck nicht ausgeführt wird. Dieses Problem lässt sich mithilfe eines Zählers und einer „ QMutex “ lösen, die diesen schützt. Hier ist beispielsweise der neue Code für die Worker-Threads:

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

    do_something();

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

Hier ist der Code für den vierten Thread:

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();
}

Der Mutex ist notwendig, da die Ergebnisse zweier Threads, die gleichzeitig versuchen, den Wert derselben Variablen zu ändern, unvorhersehbar sind.

Wartebedingungen sind eine leistungsstarke Primitive zur Thread-Synchronisation. Das Beispiel „Producer und Consumer mit Wartebedingungen“ zeigt, wie man `QWaitCondition` als Alternative zu ` QSemaphore ` verwenden kann, um den Zugriff auf einen zirkulären Puffer zu steuern, der von einem Producer-Thread und einem Consumer-Thread gemeinsam genutzt wird.

Siehe auch „ QMutex“ , „ QSemaphore “, „ QThread “ und „Producer und Consumer mit Wait-Bedingungen“.

Dokumentation zu den Member-Funktionen

QWaitCondition::QWaitCondition()

Erstellt ein neues Objekt für eine Wartebedingung.

[noexcept] QWaitCondition::~QWaitCondition()

Löscht das Wartebedingungsobjekt.

void QWaitCondition::notify_all()

Diese Funktion dient der STL-Kompatibilität. Sie entspricht der Funktion „ wakeAll()“.

void QWaitCondition::notify_one()

Diese Funktion dient der STL-Kompatibilität. Sie entspricht der Funktion „ wakeOne()“.

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

Gibt den „ lockedMutex “ frei und wartet auf die Wartebedingung. Der „ lockedMutex “ muss zuvor vom aufrufenden Thread gesperrt worden sein. Befindet sich „ lockedMutex “ nicht im gesperrten Zustand, ist das Verhalten undefiniert. Handelt es sich bei „ lockedMutex “ um einen rekursiven Mutex, kehrt diese Funktion sofort zurück. Der „ lockedMutex “ wird entsperrt, und der aufrufende Thread wird blockiert, bis eine der folgenden Bedingungen erfüllt ist:

  • Ein anderer Thread sendet ihm ein Signal über ` wakeOne()` oder ` wakeAll()`. In diesem Fall gibt diese Funktion „true“ zurück.
  • Die durch ` deadline ` angegebene Frist ist abgelaufen. Wenn ` deadline ` auf ` QDeadlineTimer::Forever ` gesetzt ist (Standard), läuft das Warten niemals ab (das Ereignis muss signalisiert werden). Diese Funktion gibt `false` zurück, wenn das Warten abgelaufen ist.

Das ` lockedMutex ` wird in denselben gesperrten Zustand zurückgegeben. Diese Funktion ermöglicht den atomaren Übergang vom gesperrten Zustand in den Wartezustand.

Siehe auch „ wakeOne()“ und „ wakeAll()“.

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

Gibt den „ lockedReadWriteLock “ frei und wartet auf die Wartebedingung. Der „ lockedReadWriteLock “ muss zuvor vom aufrufenden Thread gesperrt worden sein. Befindet sich „ lockedReadWriteLock “ nicht im gesperrten Zustand, kehrt diese Funktion sofort zurück. Der „ lockedReadWriteLock “ darf nicht rekursiv gesperrt werden, da die Funktion andernfalls die Sperre nicht ordnungsgemäß freigibt. Der „ lockedReadWriteLock “ wird entsperrt, und der aufrufende Thread wird blockiert, bis eine der folgenden Bedingungen erfüllt ist:

  • Ein anderer Thread sendet ein Signal mit ` wakeOne()` oder ` wakeAll()`. In diesem Fall gibt diese Funktion „true“ zurück.
  • Die durch ` deadline ` angegebene Frist ist abgelaufen. Wenn ` deadline ` auf ` QDeadlineTimer::Forever ` gesetzt ist (Standard), läuft die Wartezeit niemals ab (das Ereignis muss signalisiert werden). Diese Funktion gibt `false` zurück, wenn die Wartezeit abgelaufen ist.

Das ` lockedReadWriteLock ` wird im gleichen gesperrten Zustand zurückgegeben. Diese Funktion dient dazu, den atomaren Übergang vom gesperrten Zustand in den Wartezustand zu ermöglichen.

Siehe auch „ wakeOne()“ und „ wakeAll()“.

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

Gibt die „ lockedMutex “ frei und wartet time Millisekunden lang auf die Wartebedingung.

Dies ist eine überladene Funktion.

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

Gibt den „ lockedReadWriteLock “ frei und wartet time Millisekunden lang auf die Wartebedingung.

Dies ist eine überladene Funktion.

void QWaitCondition::wakeAll()

Weckt alle Threads, die auf die Wartebedingung warten. Die Reihenfolge, in der die Threads geweckt werden, hängt von den Scheduling-Richtlinien des Betriebssystems ab und lässt sich weder steuern noch vorhersagen.

Siehe auch wakeOne().

void QWaitCondition::wakeOne()

Weckt einen Thread, der auf die Wartebedingung wartet. Welcher Thread geweckt wird, hängt von den Scheduling-Richtlinien des Betriebssystems ab und lässt sich weder steuern noch vorhersagen.

Wenn Sie einen bestimmten Thread wecken möchten, besteht die Lösung in der Regel darin, verschiedene Wartebedingungen zu verwenden und verschiedene Threads auf unterschiedliche Bedingungen warten zu lassen.

Siehe auch ` wakeAll()`.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.