QThreadPool Class

Die Klasse QThreadPool verwaltet eine Sammlung von QThreads. Mehr...

Kopfzeile: #include <QThreadPool>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
Vererbungen: QObject

Hinweis: Alle Funktionen in dieser Klasse sind thread-sicher.

Eigenschaften

Öffentliche Funktionen

QThreadPool(QObject *parent = nullptr)
virtual ~QThreadPool()
int activeThreadCount() const
void clear()
(since 6.0) bool contains(const QThread *thread) const
int expiryTimeout() const
int maxThreadCount() const
void releaseThread()
void reserveThread()
void setExpiryTimeout(int expiryTimeout)
void setMaxThreadCount(int maxThreadCount)
void setStackSize(uint stackSize)
void setThreadPriority(QThread::Priority priority)
uint stackSize() const
void start(QRunnable *runnable, int priority = 0)
void start(Callable &&callableToRun, int priority = 0)
(since 6.3) void startOnReservedThread(QRunnable *runnable)
(since 6.3) void startOnReservedThread(Callable &&callableToRun)
QThread::Priority threadPriority() const
bool tryStart(QRunnable *runnable)
bool tryStart(Callable &&callableToRun)
bool tryTake(QRunnable *runnable)
(since 6.8) bool waitForDone(QDeadlineTimer deadline = QDeadlineTimer::Forever)
bool waitForDone(int msecs)

Statische öffentliche Mitglieder

QThreadPool *globalInstance()

Detaillierte Beschreibung

QThreadPool verwaltet und recycelt einzelne QThread Objekte, um die Kosten für die Erstellung von Threads in Programmen, die Threads verwenden, zu reduzieren. Jede Qt-Anwendung verfügt über ein globales QThreadPool-Objekt, auf das durch den Aufruf von globalInstance() zugegriffen werden kann.

Um einen der QThreadPool-Threads zu verwenden, untergliedern Sie QRunnable und implementieren Sie die virtuelle Funktion run(). Erstellen Sie dann ein Objekt dieser Klasse und übergeben Sie es an QThreadPool::start().

class HelloWorldTask : public QRunnable
{ void run() override    {
        qDebug() << "Hello world from thread" << QThread::currentThread();
    } }; HelloWorldTask *hello = new HelloWorldTask();// QThreadPool übernimmt den Besitz und löscht 'hello' automatischQThreadPool::globalInstance()->start(hello);

QThreadPool löscht die QRunnable standardmäßig automatisch. Verwenden Sie QRunnable::setAutoDelete(), um das Flag für das automatische Löschen zu ändern.

QThreadPool unterstützt die mehrmalige Ausführung desselben QRunnable durch den Aufruf von tryStart(this) aus QRunnable::run(). Wenn autoDelete aktiviert ist, wird die QRunnable gelöscht, wenn der letzte Thread die Run-Funktion beendet. Der mehrfache Aufruf von start() mit demselben QRunnable, wenn autoDelete aktiviert ist, erzeugt eine Race Condition und wird nicht empfohlen.

Threads, die eine bestimmte Zeit lang nicht benutzt werden, laufen ab. Die Standardzeitspanne für den Ablauf beträgt 30000 Millisekunden (30 Sekunden). Dies kann mit setExpiryTimeout() geändert werden. Die Einstellung eines negativen Ablaufzeitpunkts deaktiviert den Ablaufmechanismus.

Rufen Sie maxThreadCount() auf, um die maximale Anzahl der zu verwendenden Threads abzufragen. Falls erforderlich, können Sie das Limit mit setMaxThreadCount() ändern. Der Standardwert für maxThreadCount() ist QThread::idealThreadCount(). Die Funktion activeThreadCount() gibt die Anzahl der derzeit arbeitenden Threads zurück.

Die Funktion reserveThread() reserviert einen Thread für die externe Verwendung. Verwenden Sie releaseThread(), wenn Sie mit dem Thread fertig sind, so dass er wiederverwendet werden kann. Im Wesentlichen erhöhen oder reduzieren diese Funktionen vorübergehend die Anzahl der aktiven Threads und sind nützlich bei der Implementierung zeitaufwändiger Operationen, die für den QThreadPool nicht sichtbar sind.

Beachten Sie, dass QThreadPool eine Low-Level-Klasse für die Verwaltung von Threads ist. Alternativen auf höherer Ebene finden Sie im Modul Qt Concurrent.

Siehe auch QRunnable.

Dokumentation der Eigenschaften

[read-only] activeThreadCount : const int

Diese Eigenschaft enthält die Anzahl der aktiven Threads im Thread-Pool.

Hinweis: Es ist möglich, dass diese Funktion einen Wert zurückgibt, der größer ist als maxThreadCount(). Siehe reserveThread() für weitere Details.

Zugriffsfunktionen:

int activeThreadCount() const

Siehe auch reserveThread() und releaseThread().

expiryTimeout : int

Diese Eigenschaft enthält den Timeout-Wert für den Thread-Ablauf in Millisekunden.

Threads, die für expiryTimeout Millisekunden nicht genutzt werden, gelten als abgelaufen und werden beendet. Solche Threads werden bei Bedarf neu gestartet. Der Standardwert expiryTimeout ist 30000 Millisekunden (30 Sekunden). Wenn expiryTimeout negativ ist, laufen neu erstellte Threads nicht ab, d.h. sie werden erst beendet, wenn der Thread-Pool zerstört wird.

Beachten Sie, dass die Einstellung expiryTimeout keine Auswirkungen auf bereits laufende Threads hat. Nur neu erstellte Threads verwenden die neue expiryTimeout. Wir empfehlen, expiryTimeout unmittelbar nach der Erstellung des Threadpools, aber vor dem Aufruf von start() zu setzen.

Zugriffsfunktionen:

int expiryTimeout() const
void setExpiryTimeout(int expiryTimeout)

maxThreadCount : int

Diese Eigenschaft enthält die maximale Anzahl von Threads, die vom Thread-Pool verwendet werden. Diese Eigenschaft wird standardmäßig auf den Wert von QThread::idealThreadCount() gesetzt, wenn das QThreadPool Objekt erstellt wird.

Hinweis: Der Thread-Pool wird immer mindestens 1 Thread verwenden, auch wenn maxThreadCount limit null oder negativ ist.

Der Standardwert von maxThreadCount ist QThread::idealThreadCount().

Zugriffsfunktionen:

int maxThreadCount() const
void setMaxThreadCount(int maxThreadCount)

stackSize : uint

Diese Eigenschaft enthält die Stapelgröße für die Arbeits-Threads des Thread-Pools.

Der Wert der Eigenschaft wird nur verwendet, wenn der Thread-Pool neue Threads erstellt. Eine Änderung hat keine Auswirkung auf bereits erstellte oder laufende Threads.

Der Standardwert ist 0, so dass QThread die Standard-Stackgröße des Betriebssystems verwendet.

Zugriffsfunktionen:

uint stackSize() const
void setStackSize(uint stackSize)

[since 6.2] threadPriority : QThread::Priority

Diese Eigenschaft enthält die Thread-Priorität für neue Arbeits-Threads.

Der Wert der Eigenschaft wird nur verwendet, wenn der Thread-Pool neue Threads startet. Eine Änderung dieser Eigenschaft hat keine Auswirkungen auf bereits laufende Threads.

Der Standardwert ist QThread::InheritPriority, wodurch QThread die gleiche Priorität verwendet wie das QThreadPool Objekt.

Diese Eigenschaft wurde in Qt 6.2 eingeführt.

Zugriffsfunktionen:

QThread::Priority threadPriority() const
void setThreadPriority(QThread::Priority priority)

Siehe auch QThread::Priority.

Dokumentation der Mitgliedsfunktionen

QThreadPool::QThreadPool(QObject *parent = nullptr)

Konstruiert einen Thread-Pool mit der angegebenen parent.

[virtual noexcept] QThreadPool::~QThreadPool()

Zerstört die QThreadPool. Diese Funktion blockiert, bis alle Runnables abgeschlossen sind.

void QThreadPool::clear()

Entfernt die Runnables, die noch nicht gestartet sind, aus der Warteschlange. Die Runnables, für die runnable->autoDelete() true zurückgibt, werden gelöscht.

Siehe auch start().

[since 6.0] bool QThreadPool::contains(const QThread *thread) const

Gibt true zurück, wenn thread ein Thread ist, der von diesem Threadpool verwaltet wird.

Diese Funktion wurde in Qt 6.0 eingeführt.

[static] QThreadPool *QThreadPool::globalInstance()

Gibt die globale Instanz QThreadPool zurück.

void QThreadPool::releaseThread()

Gibt einen Thread frei, der zuvor durch einen Aufruf von reserveThread() reserviert wurde.

Hinweis: Ein Aufruf dieser Funktion ohne vorherige Reservierung eines Threads erhöht vorübergehend maxThreadCount(). Dies ist nützlich, wenn ein Thread in den Schlaf geht und auf weitere Arbeit wartet, so dass andere Threads weiterarbeiten können. Stellen Sie sicher, dass Sie reserveThread() aufrufen, wenn Sie mit dem Warten fertig sind, damit der Thread-Pool activeThreadCount() korrekt beibehalten kann.

Siehe auch reserveThread().

void QThreadPool::reserveThread()

Reserviert einen Thread, ohne Rücksicht auf activeThreadCount() und maxThreadCount().

Sobald Sie mit dem Thread fertig sind, rufen Sie releaseThread() auf, damit er wieder verwendet werden kann.

Hinweis: Auch wenn Sie maxThreadCount() oder mehr Threads reservieren, lässt der Thread-Pool immer noch mindestens einen Thread zu.

Hinweis: Diese Funktion erhöht die gemeldete Anzahl der aktiven Threads. Das bedeutet, dass bei Verwendung dieser Funktion activeThreadCount() einen größeren Wert als maxThreadCount() zurückgeben kann.

Siehe auch releaseThread().

void QThreadPool::start(QRunnable *runnable, int priority = 0)

Reserviert einen Thread und verwendet ihn zur Ausführung von runnable, es sei denn, dieser Thread führt dazu, dass die aktuelle Thread-Anzahl maxThreadCount() überschreitet. In diesem Fall wird runnable stattdessen zu einer Warteschlange hinzugefügt. Das Argument priority kann verwendet werden, um die Reihenfolge der Ausführung in der Warteschlange zu steuern.

Beachten Sie, dass der Thread-Pool das Eigentum an runnable übernimmt, wenn runnable->autoDelete() true zurückgibt, und dass runnable automatisch vom Thread-Pool gelöscht wird, nachdem runnable->run() zurückgekehrt ist. Wenn runnable->autoDelete() false zurückgibt, bleibt das Eigentum an runnable beim Aufrufer. Beachten Sie, dass eine Änderung der automatischen Löschung auf runnable nach dem Aufruf dieser Funktion zu undefiniertem Verhalten führt.

template <typename Callable, QRunnable::if_callable<Callable> = true> void QThreadPool::start(Callable &&callableToRun, int priority = 0)

Dies ist eine überladene Funktion.

Reserviert einen Thread und verwendet ihn, um callableToRun auszuführen, es sei denn, dieser Thread führt dazu, dass die aktuelle Threadanzahl maxThreadCount() überschreitet. In diesem Fall wird callableToRun stattdessen zu einer Warteschlange hinzugefügt. Das Argument priority kann verwendet werden, um die Reihenfolge der Ausführung in der Warteschlange zu steuern.

Hinweis: Diese Funktion nimmt nur dann an der Überlastauflösung teil, wenn Callable eine Funktion oder ein Funktionsobjekt ist, das mit null Argumenten aufgerufen werden kann.

Hinweis: In Qt-Versionen vor 6.6 nahm diese Funktion std::function<void()> an und konnte daher keine move-only callables verarbeiten.

[since 6.3] void QThreadPool::startOnReservedThread(QRunnable *runnable)

Gibt einen zuvor mit reserveThread() reservierten Thread frei und verwendet ihn zur Ausführung von runnable.

Beachten Sie, dass der Thread-Pool das Eigentum an runnable übernimmt, wenn runnable->autoDelete() true zurückgibt, und dass runnable automatisch vom Thread-Pool gelöscht wird, nachdem runnable->run() zurückgekehrt ist. Wenn runnable->autoDelete() false zurückgibt, bleibt das Eigentum an runnable beim Aufrufer. Beachten Sie, dass das Ändern der automatischen Löschung auf runnable nach dem Aufruf dieser Funktion zu undefiniertem Verhalten führt.

Hinweis: Der Aufruf dieser Funktion, wenn keine Threads reserviert sind, führt zu undefiniertem Verhalten.

Diese Funktion wurde in Qt 6.3 eingeführt.

Siehe auch reserveThread() und start().

[since 6.3] template <typename Callable, QRunnable::if_callable<Callable> = true> void QThreadPool::startOnReservedThread(Callable &&callableToRun)

Dies ist eine überladene Funktion.

Gibt einen zuvor mit reserveThread() reservierten Thread frei und verwendet ihn zur Ausführung von callableToRun.

Hinweis: Diese Funktion nimmt nur an der Überladungsauflösung teil, wenn Callable eine Funktion oder ein Funktionsobjekt ist, das mit null Argumenten aufgerufen werden kann.

Hinweis: In Qt-Versionen vor 6.6 nahm diese Funktion std::function<void()> an und konnte daher nicht mit move-only callables umgehen.

Diese Funktion wurde in Qt 6.3 eingeführt.

bool QThreadPool::tryStart(QRunnable *runnable)

Versucht, einen Thread für die Ausführung von runnable zu reservieren.

Wenn zum Zeitpunkt des Aufrufs keine Threads verfügbar sind, tut diese Funktion nichts und gibt false zurück. Andernfalls wird runnable sofort unter Verwendung eines verfügbaren Threads ausgeführt und diese Funktion gibt true zurück.

Beachten Sie, dass bei Erfolg der Thread-Pool das Eigentum an runnable übernimmt, wenn runnable->autoDelete() true zurückgibt, und dass runnable automatisch vom Thread-Pool gelöscht wird, nachdem runnable->run() zurückgekehrt ist. Wenn runnable->autoDelete() false zurückgibt, bleibt das Eigentum an runnable beim Aufrufer. Beachten Sie, dass das Ändern der automatischen Löschung auf runnable nach dem Aufruf dieser Funktion zu undefiniertem Verhalten führt.

template <typename Callable, QRunnable::if_callable<Callable> = true> bool QThreadPool::tryStart(Callable &&callableToRun)

Dies ist eine überladene Funktion.

Versucht, einen Thread für die Ausführung von callableToRun zu reservieren.

Wenn zum Zeitpunkt des Aufrufs keine Threads verfügbar sind, tut diese Funktion nichts und gibt false zurück. Andernfalls wird callableToRun sofort unter Verwendung eines verfügbaren Threads ausgeführt und diese Funktion gibt true zurück.

Hinweis: Diese Funktion nimmt nur dann an der Überlastauflösung teil, wenn Callable eine Funktion oder ein Funktionsobjekt ist, das mit null Argumenten aufgerufen werden kann.

Hinweis: In Qt-Versionen vor 6.6 nahm diese Funktion std::function<void()> an und konnte daher nicht mit move-only callables umgehen.

bool QThreadPool::tryTake(QRunnable *runnable)

Versucht, das angegebene runnable aus der Warteschlange zu entfernen, wenn es noch nicht gestartet ist. Wenn die Runnable noch nicht gestartet wurde, wird true zurückgegeben, und das Eigentum an runnable wird an den Aufrufer übertragen (auch wenn runnable->autoDelete() == true). Andernfalls wird false zurückgegeben.

Hinweis: Falls runnable->autoDelete() == true, kann diese Funktion die falsche Runnable entfernen. Dies ist als ABA-Problem bekannt: Das ursprüngliche runnable kann bereits ausgeführt worden sein und wurde inzwischen gelöscht. Der Speicher wird für eine andere Runnable wiederverwendet, die dann anstelle der vorgesehenen Runnable entfernt wird. Aus diesem Grund empfehlen wir, diese Funktion nur für Runnables aufzurufen, die nicht automatisch gelöscht werden.

Siehe auch start() und QRunnable::autoDelete().

[since 6.8] bool QThreadPool::waitForDone(QDeadlineTimer deadline = QDeadlineTimer::Forever)

Wartet, bis deadline abläuft, damit alle Threads beendet werden können, und entfernt alle Threads aus dem Thread-Pool. Gibt true zurück, wenn alle Threads entfernt wurden; andernfalls wird false zurückgegeben.

Diese Funktion wurde in Qt 6.8 eingeführt.

bool QThreadPool::waitForDone(int msecs)

Wartet bis zu msecs Millisekunden, bis alle Threads beendet sind, und entfernt alle Threads aus dem Thread-Pool. Gibt true zurück, wenn alle Threads entfernt wurden; andernfalls gibt sie false zurück. Wenn msecs gleich -1 ist, wartet diese Funktion auf das Beenden des letzten Threads.

© 2025 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.