Sur cette page

QThreadPool Class

La classe QThreadPool gère une collection de QThreads. Plus d'informations...

En-tête : #include <QThreadPool>
CMake : find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake : QT += core
Héritages : QObject

Remarque : toutes les fonctions de cette classe sont sûres pour les threads.

Propriétés

Fonctions publiques

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()
(since 6.9) QThread::QualityOfService serviceLevel() const
void setExpiryTimeout(int expiryTimeout)
void setMaxThreadCount(int maxThreadCount)
(since 6.9) void setServiceLevel(QThread::QualityOfService serviceLevel)
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)

Membres publics statiques

QThreadPool *globalInstance()

Description détaillée

QThreadPool gère et recycle les objets QThread afin de réduire les coûts de création de threads dans les programmes qui en utilisent. Chaque application Qt possède un objet QThreadPool global, auquel on peut accéder en appelant globalInstance().

Pour utiliser l'un des threads du QThreadPool, sous-classez QRunnable et implémentez la fonction virtuelle run(). Créez ensuite un objet de cette classe et passez-le à QThreadPool::start().

class HelloWorldTask : public QRunnable
{ void run() override    {
        qDebug() << "Hello world from thread" << QThread::currentThread();
    } } ;int main() { //...HelloWorldTask *hello = new HelloWorldTask() ; // QThreadPool prend possession de 'hello' et le supprime automatiquement   QThreadPool::globalInstance()->start(hello) ; //... }

Par défaut, QThreadPool supprime automatiquement le site QRunnable. Utilisez QRunnable::setAutoDelete() pour modifier le drapeau de suppression automatique.

QThreadPool prend en charge l'exécution du même QRunnable plus d'une fois en appelant tryStart(this) à partir de QRunnable::run(). Si l'option autoDelete est activée, l'adresse QRunnable sera supprimée lorsque le dernier thread quittera la fonction d'exécution. Appeler start() plusieurs fois avec le même QRunnable quand autoDelete est activé crée une condition de course et n'est pas recommandé.

Les threads inutilisés pendant un certain temps expirent. Le délai d'expiration par défaut est de 30000 millisecondes (30 secondes). Il peut être modifié à l'aide de setExpiryTimeout(). La définition d'un délai d'expiration négatif désactive le mécanisme d'expiration.

Appelez maxThreadCount() pour demander le nombre maximum de threads à utiliser. Si nécessaire, vous pouvez modifier la limite avec setMaxThreadCount(). La valeur par défaut de maxThreadCount() est QThread::idealThreadCount(). La fonction activeThreadCount() renvoie le nombre de threads en cours d'exécution.

La fonction reserveThread() réserve un thread pour un usage externe. Utilisez la fonction releaseThread() lorsque vous avez terminé le thread, afin qu'il puisse être réutilisé. Essentiellement, ces fonctions augmentent ou réduisent temporairement le nombre de threads actifs et sont utiles pour mettre en œuvre des opérations qui prennent du temps et qui ne sont pas visibles par le QThreadPool.

Notez que QThreadPool est une classe de bas niveau pour la gestion des threads, voir le module Qt Concurrent pour des alternatives de plus haut niveau.

Voir également QRunnable.

Documentation sur les propriétés

[read-only] activeThreadCount : int

Cette propriété indique le nombre de threads actifs dans le pool de threads.

Remarque : il est possible que cette fonction renvoie une valeur supérieure à maxThreadCount(). Voir reserveThread() pour plus de détails.

Fonctions d'accès :

int activeThreadCount() const

Voir également reserveThread() et releaseThread().

expiryTimeout : int

Cette propriété contient la valeur du délai d'expiration des threads en millisecondes.

Les threads qui ne sont pas utilisés pendant expiryTimeout millisecondes sont considérés comme ayant expiré et se terminent. Ces threads seront redémarrés si nécessaire. La valeur par défaut de expiryTimeout est de 30000 millisecondes (30 secondes). Si expiryTimeout est négatif, les threads nouvellement créés n'expireront pas, c'est-à-dire qu'ils ne sortiront pas avant que le pool de threads ne soit détruit.

Notez que le réglage de expiryTimeout n'a aucun effet sur les threads déjà en cours d'exécution. Seules les threads nouvellement créés utiliseront le nouveau expiryTimeout. Nous recommandons de définir expiryTimeout immédiatement après la création du pool de threads, mais avant d'appeler start().

Fonctions d'accès :

int expiryTimeout() const
void setExpiryTimeout(int expiryTimeout)

maxThreadCount : int

Cette propriété contient le nombre maximum de threads utilisés par le pool de threads. Cette propriété prend par défaut la valeur de QThread::idealThreadCount() au moment de la création de l'objet QThreadPool.

Remarque : le pool de threads utilisera toujours au moins un thread, même si la limite de maxThreadCount est nulle ou négative.

La valeur par défaut de maxThreadCount est QThread::idealThreadCount().

Fonctions d'accès :

int maxThreadCount() const
void setMaxThreadCount(int maxThreadCount)

stackSize : uint

Cette propriété définit la taille de la pile des threads de travail du pool de threads.

La valeur de cette propriété n'est utilisée que lorsque le pool de threads crée de nouveaux threads. Sa modification n'a aucun effet sur les threads déjà créés ou en cours d'exécution.

La valeur par défaut est 0, ce qui fait que QThread utilise la taille de pile par défaut du système d'exploitation.

Fonctions d'accès :

uint stackSize() const
void setStackSize(uint stackSize)

[since 6.2] threadPriority : QThread::Priority

Cette propriété définit la priorité des nouveaux threads de travail.

La valeur de cette propriété n'est utilisée que lorsque le pool de threads démarre de nouveaux threads. La modifier n'a aucun effet sur les threads déjà en cours d'exécution.

La valeur par défaut est QThread::InheritPriority, ce qui fait que QThread utilise la même priorité que celle de l'objet QThreadPool.

Cette propriété a été introduite dans Qt 6.2.

Fonctions d'accès :

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

Voir également QThread::Priority.

Documentation sur les fonctions membres

QThreadPool::QThreadPool(QObject *parent = nullptr)

Construit un pool de threads avec l'adresse parent.

[virtual noexcept] QThreadPool::~QThreadPool()

Détruit le site QThreadPool. Cette fonction se bloque jusqu'à ce que tous les exécutables soient terminés.

void QThreadPool::clear()

Supprime de la file d'attente les exécutables qui n'ont pas encore été lancés. Les exécutables pour lesquels runnable->autoDelete() renvoie true sont supprimés.

Voir aussi start().

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

Renvoie true si thread est un thread géré par ce pool de threads.

Cette fonction a été introduite dans Qt 6.0.

[static] QThreadPool *QThreadPool::globalInstance()

Renvoie l'instance globale de QThreadPool.

void QThreadPool::releaseThread()

Libère un thread précédemment réservé par un appel à reserveThread().

Remarque : l'appel à cette fonction sans réservation préalable d'un thread augmente temporairement maxThreadCount(). Cette fonction est utile lorsqu'un thread se met en veille en attendant un travail supplémentaire, ce qui permet à d'autres threads de continuer. Veillez à appeler reserveThread() lorsque vous avez fini d'attendre, afin que le pool de threads puisse maintenir correctement la valeur de activeThreadCount().

Voir aussi reserveThread().

void QThreadPool::reserveThread()

Réserve un fil de discussion, sans tenir compte de activeThreadCount() et maxThreadCount().

Une fois que vous avez terminé avec le thread, appelez releaseThread() pour permettre sa réutilisation.

Remarque : Même si vous réservez maxThreadCount() threads ou plus, le pool de threads autorisera toujours un minimum d'un thread.

Remarque : cette fonction augmente le nombre de threads actifs signalés. Cela signifie qu'en utilisant cette fonction, il est possible que activeThreadCount() renvoie une valeur supérieure à maxThreadCount().

Voir également releaseThread().

[since 6.9] QThread::QualityOfService QThreadPool::serviceLevel() const

Renvoie le niveau de qualité de service actuel du thread.

Cette fonction a été introduite dans Qt 6.9.

Voir aussi setServiceLevel() et QThread::serviceLevel().

[since 6.9] void QThreadPool::setServiceLevel(QThread::QualityOfService serviceLevel)

Définit le niveau de qualité de service des objets threads créés après l'appel à ce setter à serviceLevel.

Le support n'est pas disponible sur toutes les plateformes. Consultez QThread::setServiceLevel() pour plus de détails.

Cette fonction a été introduite dans Qt 6.9.

Voir également serviceLevel() et QThread::serviceLevel().

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

Réserve un thread et l'utilise pour exécuter runnable, à moins que ce thread ne fasse dépasser le nombre de threads en cours à maxThreadCount(). Dans ce cas, runnable est ajouté à une file d'attente d'exécution. L'argument priority peut être utilisé pour contrôler l'ordre d'exécution de la file d'attente.

Notez que le pool de threads prend possession de runnable si runnable->autoDelete() renvoie true, et que runnable sera supprimé automatiquement par le pool de threads après le retour de runnable->run(). Si runnable->autoDelete() renvoie false, runnable reste la propriété de l'appelant. Notez que la modification de l'effacement automatique de runnable après l'appel de cette fonction entraîne un comportement indéfini.

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

Réserve un thread et l'utilise pour exécuter callableToRun, à moins que ce thread ne fasse dépasser le nombre de threads en cours à maxThreadCount(). Dans ce cas, callableToRun est ajouté à une file d'attente d'exécution. L'argument priority peut être utilisé pour contrôler l'ordre d'exécution de la file d'attente.

Note : Dans les versions de Qt antérieures à la 6.6, cette fonction prenait std::function<void()>, et ne pouvait donc pas gérer les callables de type "move-only".

Contraintes

Participe à la résolution des surcharges uniquement si Callable est une fonction ou un objet fonction qui peut être appelé avec zéro argument.

Il s'agit d'une fonction surchargée.

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

Libère un thread précédemment réservé avec reserveThread() et l'utilise pour exécuter runnable.

Notez que le pool de threads prend possession de runnable si runnable->autoDelete() renvoie true, et que runnable sera supprimé automatiquement par le pool de threads après le retour de runnable->run(). Si runnable->autoDelete() renvoie false, runnable reste la propriété de l'appelant. Notez que la modification de l'effacement automatique de runnable après l'appel de cette fonction entraîne un comportement indéfini.

Remarque : L'appel de cette fonction lorsqu'aucun thread n'est réservé entraîne un comportement non défini.

Cette fonction a été introduite dans Qt 6.3.

Voir aussi reserveThread() et start().

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

Libère un thread précédemment réservé avec reserveThread() et l'utilise pour exécuter callableToRun.

Note : Dans les versions de Qt antérieures à la 6.6, cette fonction prenait std::function<void()>, et ne pouvait donc pas gérer les callables de type move-only.

Contraintes

Participe à la résolution des surcharges uniquement si Callable est une fonction ou un objet fonction qui peut être appelé avec zéro argument.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.3.

bool QThreadPool::tryStart(QRunnable *runnable)

Tente de réserver un thread pour l'exécution runnable.

Si aucun thread n'est disponible au moment de l'appel, cette fonction ne fait rien et renvoie false. Dans le cas contraire, runnable est exécuté immédiatement en utilisant un thread disponible et cette fonction renvoie true.

Notez qu'en cas de succès, le pool de threads prend possession de runnable si runnable->autoDelete() renvoie true, et que runnable sera automatiquement supprimé par le pool de threads après le retour de runnable->run(). Si runnable->autoDelete() renvoie false, la propriété de runnable reste à l'appelant. Notez que la modification de l'effacement automatique de runnable après l'appel de cette fonction entraîne un comportement indéfini.

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

Tente de réserver un thread pour l'exécution callableToRun.

Si aucun thread n'est disponible au moment de l'appel, cette fonction ne fait rien et renvoie false. Sinon, callableToRun est exécuté immédiatement en utilisant un thread disponible et cette fonction renvoie true.

Note : Dans les versions de Qt antérieures à la 6.6, cette fonction utilisait std::function<void()>, et ne pouvait donc pas gérer les callables de type "move-only".

Contraintes

Participe à la résolution des surcharges uniquement si Callable est une fonction ou un objet fonction qui peut être appelé avec zéro argument.

Il s'agit d'une fonction surchargée.

bool QThreadPool::tryTake(QRunnable *runnable)

Tente de retirer le runnable spécifié de la file d'attente s'il n'est pas encore démarré. Si l'exécutable n'a pas été démarré, renvoie true, et la propriété de runnable est transférée à l'appelant (même si runnable->autoDelete() == true). Sinon, elle renvoie false.

Remarque : si runnable->autoDelete() == true, cette fonction peut supprimer le mauvais objet d'exécution. C'est ce qu'on appelle le problème ABA: l'original runnable a peut-être déjà été exécuté et a été supprimé depuis. La mémoire est réutilisée pour un autre objet d'exécution, qui est alors supprimé au lieu de l'objet prévu. Pour cette raison, nous recommandons d'appeler cette fonction uniquement pour les exécutables qui ne s'effacent pas automatiquement.

Voir aussi start() et QRunnable::autoDelete().

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

Attend l'expiration de deadline pour que tous les threads se retirent et supprime tous les threads du pool de threads. Retourne true si tous les threads ont été supprimés ; sinon, il retourne false.

Cette fonction a été introduite dans Qt 6.8.

bool QThreadPool::waitForDone(int msecs)

Attend jusqu'à msecs millisecondes que tous les threads soient sortis et supprime tous les threads du pool de threads. Elle renvoie true si tous les threads ont été supprimés, sinon elle renvoie false. Si msecs vaut -1, cette fonction attend que le dernier thread se termine.

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