Qt 4.8
Public Functions | Static Public Functions | Properties | Friends | List of all members
QThreadPool Class Reference

The QThreadPool class manages a collection of QThreads. More...

#include <qthreadpool.h>

Inheritance diagram for QThreadPool:
QObject

Public Functions

int activeThreadCount () const
 
int expiryTimeout () const
 
int maxThreadCount () const
 
 QThreadPool (QObject *parent=0)
 Constructs a thread pool with the given parent. More...
 
void releaseThread ()
 Releases a thread previously reserved by a call to reserveThread(). More...
 
void reserveThread ()
 Reserves one thread, disregarding activeThreadCount() and maxThreadCount(). More...
 
void setExpiryTimeout (int expiryTimeout)
 
void setMaxThreadCount (int maxThreadCount)
 
void start (QRunnable *runnable, int priority=0)
 Reserves a thread and uses it to run runnable, unless this thread will make the current thread count exceed maxThreadCount(). More...
 
bool tryStart (QRunnable *runnable)
 Attempts to reserve a thread to run runnable. More...
 
void waitForDone ()
 Waits for each thread to exit and removes all threads from the thread pool. More...
 
bool waitForDone (int msecs)
 
 ~QThreadPool ()
 Destroys the QThreadPool. More...
 
- Public Functions inherited from QObject
bool blockSignals (bool b)
 If block is true, signals emitted by this object are blocked (i.e., emitting a signal will not invoke anything connected to it). More...
 
const QObjectListchildren () const
 Returns a list of child objects. More...
 
bool connect (const QObject *sender, const char *signal, const char *member, Qt::ConnectionType type=Qt::AutoConnection) const
 
bool disconnect (const char *signal=0, const QObject *receiver=0, const char *member=0)
 
bool disconnect (const QObject *receiver, const char *member=0)
 
void dumpObjectInfo ()
 Dumps information about signal connections, etc. More...
 
void dumpObjectTree ()
 Dumps a tree of children to the debug output. More...
 
QList< QByteArraydynamicPropertyNames () const
 Returns the names of all properties that were dynamically added to the object using setProperty(). More...
 
virtual bool event (QEvent *)
 This virtual function receives events to an object and should return true if the event e was recognized and processed. More...
 
virtual bool eventFilter (QObject *, QEvent *)
 Filters events if this object has been installed as an event filter for the watched object. More...
 
template<typename T >
findChild (const QString &aName=QString()) const
 Returns the child of this object that can be cast into type T and that is called name, or 0 if there is no such object. More...
 
template<typename T >
QList< T > findChildren (const QString &aName=QString()) const
 Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects. More...
 
template<typename T >
QList< T > findChildren (const QRegExp &re) const
 
bool inherits (const char *classname) const
 Returns true if this object is an instance of a class that inherits className or a QObject subclass that inherits className; otherwise returns false. More...
 
void installEventFilter (QObject *)
 Installs an event filter filterObj on this object. More...
 
bool isWidgetType () const
 Returns true if the object is a widget; otherwise returns false. More...
 
void killTimer (int id)
 Kills the timer with timer identifier, id. More...
 
virtual const QMetaObjectmetaObject () const
 Returns a pointer to the meta-object of this object. More...
 
void moveToThread (QThread *thread)
 Changes the thread affinity for this object and its children. More...
 
QString objectName () const
 
QObjectparent () const
 Returns a pointer to the parent object. More...
 
QVariant property (const char *name) const
 Returns the value of the object's name property. More...
 
Q_INVOKABLE QObject (QObject *parent=0)
 Constructs an object with parent object parent. More...
 
void removeEventFilter (QObject *)
 Removes an event filter object obj from this object. More...
 
void setObjectName (const QString &name)
 
void setParent (QObject *)
 Makes the object a child of parent. More...
 
bool setProperty (const char *name, const QVariant &value)
 Sets the value of the object's name property to value. More...
 
void setUserData (uint id, QObjectUserData *data)
 
bool signalsBlocked () const
 Returns true if signals are blocked; otherwise returns false. More...
 
int startTimer (int interval)
 Starts a timer and returns a timer identifier, or returns zero if it could not start a timer. More...
 
QThreadthread () const
 Returns the thread in which the object lives. More...
 
QObjectUserDatauserData (uint id) const
 
virtual ~QObject ()
 Destroys the object, deleting all its child objects. More...
 

Static Public Functions

static QThreadPoolglobalInstance ()
 Returns the global QThreadPool instance. More...
 
- Static Public Functions inherited from QObject
static bool connect (const QObject *sender, const char *signal, const QObject *receiver, const char *member, Qt::ConnectionType=Qt::AutoConnection)
 Creates a connection of the given type from the signal in the sender object to the method in the receiver object. More...
 
static bool connect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type=Qt::AutoConnection)
 
static bool disconnect (const QObject *sender, const char *signal, const QObject *receiver, const char *member)
 Disconnects signal in object sender from method in object receiver. More...
 
static bool disconnect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &member)
 
static uint registerUserData ()
 
static QString tr (const char *sourceText, const char *comment=0, int n=-1)
 
static QString trUtf8 (const char *sourceText, const char *comment=0, int n=-1)
 

Properties

int activeThreadCount
 This property represents the number of active threads in the thread pool. More...
 
int expiryTimeout
 Threads that are unused for expiryTimeout milliseconds are considered to have expired and will exit. More...
 
int maxThreadCount
 This property represents the maximum number of threads used by the thread pool. More...
 

Friends

class QFutureInterfaceBase
 

Additional Inherited Members

- Public Slots inherited from QObject
void deleteLater ()
 Schedules this object for deletion. More...
 
- Signals inherited from QObject
void destroyed (QObject *=0)
 This signal is emitted immediately before the object obj is destroyed, and can not be blocked. More...
 
- Static Public Variables inherited from QObject
static const QMetaObject staticMetaObject
 This variable stores the meta-object for the class. More...
 
- Protected Functions inherited from QObject
virtual void childEvent (QChildEvent *)
 This event handler can be reimplemented in a subclass to receive child events. More...
 
virtual void connectNotify (const char *signal)
 This virtual function is called when something has been connected to signal in this object. More...
 
virtual void customEvent (QEvent *)
 This event handler can be reimplemented in a subclass to receive custom events. More...
 
virtual void disconnectNotify (const char *signal)
 This virtual function is called when something has been disconnected from signal in this object. More...
 
 QObject (QObjectPrivate &dd, QObject *parent=0)
 
int receivers (const char *signal) const
 Returns the number of receivers connected to the signal. More...
 
QObjectsender () const
 Returns a pointer to the object that sent the signal, if called in a slot activated by a signal; otherwise it returns 0. More...
 
int senderSignalIndex () const
 
virtual void timerEvent (QTimerEvent *)
 This event handler can be reimplemented in a subclass to receive timer events for the object. More...
 
- Protected Variables inherited from QObject
QScopedPointer< QObjectDatad_ptr
 
- Static Protected Variables inherited from QObject
static const QMetaObject staticQtMetaObject
 

Detailed Description

The QThreadPool class manages a collection of QThreads.

Since
4.4
Note
This class or function is threadsafe.

QThreadPool manages and recyles individual QThread objects to help reduce thread creation costs in programs that use threads. Each Qt application has one global QThreadPool object, which can be accessed by calling globalInstance().

To use one of the QThreadPool threads, subclass QRunnable and implement the run() virtual function. Then create an object of that class and pass it to QThreadPool::start().

class HelloWorldTask : public QRunnable
{
void run()
{
qDebug() << "Hello world from thread" << QThread::currentThread();
}
}
HelloWorldTask *hello = new HelloWorldTask();
// QThreadPool takes ownership and deletes 'hello' automatically

QThreadPool deletes the QRunnable automatically by default. Use QRunnable::setAutoDelete() to change the auto-deletion flag.

QThreadPool supports executing the same QRunnable more than once by calling tryStart(this) from within QRunnable::run(). If autoDelete is enabled the QRunnable will be deleted when the last thread exits the run function. Calling start() multiple times with the same QRunnable when autoDelete is enabled creates a race condition and is not recommended.

Threads that are unused for a certain amount of time will expire. The default expiry timeout is 30000 milliseconds (30 seconds). This can be changed using setExpiryTimeout(). Setting a negative expiry timeout disables the expiry mechanism.

Call maxThreadCount() to query the maximum number of threads to be used. If needed, you can change the limit with setMaxThreadCount(). The default maxThreadCount() is QThread::idealThreadCount(). The activeThreadCount() function returns the number of threads currently doing work.

The reserveThread() function reserves a thread for external use. Use releaseThread() when your are done with the thread, so that it may be reused. Essentially, these functions temporarily increase or reduce the active thread count and are useful when implementing time-consuming operations that are not visible to the QThreadPool.

Note that QThreadPool is a low-level class for managing threads, see QtConcurrent::run() or the other Concurrent Programming {Qt Concurrent} APIs for higher level alternatives.

See also
QRunnable

Definition at line 58 of file qthreadpool.h.

Constructors and Destructors

◆ QThreadPool()

QThreadPool::QThreadPool ( QObject parent = 0)

Constructs a thread pool with the given parent.

Definition at line 439 of file qthreadpool.cpp.

440  : QObject(*new QThreadPoolPrivate, parent)
441 { }
Q_INVOKABLE QObject(QObject *parent=0)
Constructs an object with parent object parent.
Definition: qobject.cpp:753

◆ ~QThreadPool()

QThreadPool::~QThreadPool ( )

Destroys the QThreadPool.

This function will block until all runnables have been completed.

Definition at line 447 of file qthreadpool.cpp.

448 {
449  d_func()->waitForDone();
450  d_func()->reset();
451 }

Functions

◆ activeThreadCount()

int QThreadPool::activeThreadCount ( ) const

Referenced by setMaxThreadCount().

◆ expiryTimeout()

int QThreadPool::expiryTimeout ( ) const

Referenced by setExpiryTimeout(), and tryStart().

◆ globalInstance()

QThreadPool * QThreadPool::globalInstance ( )
static

Returns the global QThreadPool instance.

Definition at line 456 of file qthreadpool.cpp.

Referenced by elapsed(), QFutureInterfaceBase::waitForFinished(), QFutureInterfaceBase::waitForResult(), QFutureInterfaceBase::waitForResume(), and QCoreApplication::~QCoreApplication().

457 {
458  return theInstance();
459 }

◆ maxThreadCount()

int QThreadPool::maxThreadCount ( ) const

◆ releaseThread()

void QThreadPool::releaseThread ( )

Releases a thread previously reserved by a call to reserveThread().

Note
Calling this function without previously reserving a thread temporarily increases maxThreadCount(). This is useful when a thread goes to sleep waiting for more work, allowing other threads to continue. Be sure to call reserveThread() when done waiting, so that the thread pool can correctly maintain the activeThreadCount().
See also
reserveThread()

Definition at line 636 of file qthreadpool.cpp.

Referenced by QFutureInterfaceBase::waitForResume().

637 {
638  Q_D(QThreadPool);
639  QMutexLocker locker(&d->mutex);
640  --d->reservedThreads;
641  d->tryToStartMoreThreads();
642 }
double d
Definition: qnumeric_p.h:62
#define Q_D(Class)
Definition: qglobal.h:2482
The QThreadPool class manages a collection of QThreads.
Definition: qthreadpool.h:58
The QMutexLocker class is a convenience class that simplifies locking and unlocking mutexes...
Definition: qmutex.h:101

◆ reserveThread()

void QThreadPool::reserveThread ( )

Reserves one thread, disregarding activeThreadCount() and maxThreadCount().

Once you are done with the thread, call releaseThread() to allow it to be reused.

Note
This function will always increase the number of active threads. This means that by using this function, it is possible for activeThreadCount() to return a value greater than maxThreadCount() .
See also
releaseThread()

Definition at line 617 of file qthreadpool.cpp.

Referenced by QFutureInterfaceBase::waitForResume().

618 {
619  Q_D(QThreadPool);
620  QMutexLocker locker(&d->mutex);
621  ++d->reservedThreads;
622 }
double d
Definition: qnumeric_p.h:62
#define Q_D(Class)
Definition: qglobal.h:2482
The QThreadPool class manages a collection of QThreads.
Definition: qthreadpool.h:58
The QMutexLocker class is a convenience class that simplifies locking and unlocking mutexes...
Definition: qmutex.h:101

◆ setExpiryTimeout()

void QThreadPool::setExpiryTimeout ( int  expiryTimeout)

Definition at line 545 of file qthreadpool.cpp.

546 {
547  Q_D(QThreadPool);
548  if (d->expiryTimeout == expiryTimeout)
549  return;
550  d->expiryTimeout = expiryTimeout;
551 }
double d
Definition: qnumeric_p.h:62
#define Q_D(Class)
Definition: qglobal.h:2482
The QThreadPool class manages a collection of QThreads.
Definition: qthreadpool.h:58
int expiryTimeout() const

◆ setMaxThreadCount()

void QThreadPool::setMaxThreadCount ( int  maxThreadCount)

Definition at line 573 of file qthreadpool.cpp.

Referenced by QHostInfoLookupManager::QHostInfoLookupManager().

574 {
575  Q_D(QThreadPool);
576  QMutexLocker locker(&d->mutex);
577 
578  if (maxThreadCount == d->maxThreadCount)
579  return;
580 
581  d->maxThreadCount = maxThreadCount;
582  d->tryToStartMoreThreads();
583 }
double d
Definition: qnumeric_p.h:62
#define Q_D(Class)
Definition: qglobal.h:2482
The QThreadPool class manages a collection of QThreads.
Definition: qthreadpool.h:58
The QMutexLocker class is a convenience class that simplifies locking and unlocking mutexes...
Definition: qmutex.h:101
int maxThreadCount() const

◆ start()

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

Reserves a thread and uses it to run runnable, unless this thread will make the current thread count exceed maxThreadCount().

In that case, runnable is added to a run queue instead. The priority argument can be used to control the run queue's order of execution.

Note that the thread pool takes ownership of the runnable if runnable->autoDelete() returns true, and the runnable will be deleted automatically by the thread pool after the runnable->run() returns. If runnable->autoDelete() returns false, ownership of runnable remains with the caller. Note that changing the auto-deletion on runnable after calling this functions results in undefined behavior.

Definition at line 476 of file qthreadpool.cpp.

Referenced by QHostInfoLookupManager::work().

477 {
478  if (!runnable)
479  return;
480 
481  Q_D(QThreadPool);
482  QMutexLocker locker(&d->mutex);
483  if (!d->tryStart(runnable)) {
484  d->enqueueTask(runnable, priority);
485 
486  if (!d->waitingThreads.isEmpty())
487  d->waitingThreads.takeFirst()->runnableReady.wakeOne();
488  }
489 }
double d
Definition: qnumeric_p.h:62
#define Q_D(Class)
Definition: qglobal.h:2482
The QThreadPool class manages a collection of QThreads.
Definition: qthreadpool.h:58
The QMutexLocker class is a convenience class that simplifies locking and unlocking mutexes...
Definition: qmutex.h:101

◆ tryStart()

bool QThreadPool::tryStart ( QRunnable runnable)

Attempts to reserve a thread to run runnable.

If no threads are available at the time of calling, then this function does nothing and returns false. Otherwise, runnable is run immediately using one available thread and this function returns true.

Note that the thread pool takes ownership of the runnable if runnable->autoDelete() returns true, and the runnable will be deleted automatically by the thread pool after the runnable->run() returns. If runnable->autoDelete() returns false, ownership of runnable remains with the caller. Note that changing the auto-deletion on runnable after calling this function results in undefined behavior.

Definition at line 507 of file qthreadpool.cpp.

508 {
509  if (!runnable)
510  return false;
511 
512  Q_D(QThreadPool);
513 
514  QMutexLocker locker(&d->mutex);
515 
516  if (d->allThreads.isEmpty() == false && d->activeThreadCount() >= d->maxThreadCount)
517  return false;
518 
519  return d->tryStart(runnable);
520 }
double d
Definition: qnumeric_p.h:62
#define Q_D(Class)
Definition: qglobal.h:2482
The QThreadPool class manages a collection of QThreads.
Definition: qthreadpool.h:58
The QMutexLocker class is a convenience class that simplifies locking and unlocking mutexes...
Definition: qmutex.h:101

◆ waitForDone() [1/2]

void QThreadPool::waitForDone ( )

Waits for each thread to exit and removes all threads from the thread pool.

Definition at line 647 of file qthreadpool.cpp.

Referenced by QHostInfoLookupManager::clear(), QHostInfoLookupManager::waitForThreadPoolDone(), and QCoreApplication::~QCoreApplication().

648 {
649  Q_D(QThreadPool);
650  d->waitForDone();
651  d->reset();
652 }
double d
Definition: qnumeric_p.h:62
#define Q_D(Class)
Definition: qglobal.h:2482
The QThreadPool class manages a collection of QThreads.
Definition: qthreadpool.h:58

◆ waitForDone() [2/2]

bool QThreadPool::waitForDone ( int  msecs)

Definition at line 665 of file qthreadpool.cpp.

666 {
667  Q_D(QThreadPool);
668  bool rc = d->waitForDone(msecs);
669  if (rc)
670  d->reset();
671  return rc;
672 }
double d
Definition: qnumeric_p.h:62
#define Q_D(Class)
Definition: qglobal.h:2482
The QThreadPool class manages a collection of QThreads.
Definition: qthreadpool.h:58

Friends and Related Functions

◆ QFutureInterfaceBase

friend class QFutureInterfaceBase
friend

Definition at line 65 of file qthreadpool.h.

Properties

◆ activeThreadCount

int QThreadPool::activeThreadCount
private

This property represents the number of active threads in the thread pool.

Note
It is possible for this function to return a value that is greater than maxThreadCount(). See reserveThread() for more details.
See also
reserveThread(), releaseThread()

Definition at line 64 of file qthreadpool.h.

◆ expiryTimeout

int QThreadPool::expiryTimeout
private

Threads that are unused for expiryTimeout milliseconds are considered to have expired and will exit.

Such threads will be restarted as needed. The default expiryTimeout is 30000 milliseconds (30 seconds). If expiryTimeout is negative, newly created threads will not expire, e.g., they will not exit until the thread pool is destroyed.

Note that setting expiryTimeout has no effect on already running threads. Only newly created threads will use the new expiryTimeout. We recommend setting the expiryTimeout immediately after creating the thread pool, but before calling start().

Definition at line 62 of file qthreadpool.h.

◆ maxThreadCount

int QThreadPool::maxThreadCount
private

This property represents the maximum number of threads used by the thread pool.

Note
The thread pool will always use at least 1 thread, even if maxThreadCount limit is zero or negative.

The default maxThreadCount is QThread::idealThreadCount().

Definition at line 63 of file qthreadpool.h.

Referenced by QHostInfoLookupManager::work().


The documentation for this class was generated from the following files: