diff options
Diffstat (limited to 'src/corelib/thread/qthreadpool.cpp')
| -rw-r--r-- | src/corelib/thread/qthreadpool.cpp | 298 |
1 files changed, 174 insertions, 124 deletions
diff --git a/src/corelib/thread/qthreadpool.cpp b/src/corelib/thread/qthreadpool.cpp index 4d7d7a2250..ae584656fe 100644 --- a/src/corelib/thread/qthreadpool.cpp +++ b/src/corelib/thread/qthreadpool.cpp @@ -1,51 +1,20 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the QtCore module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only #include "qthreadpool.h" #include "qthreadpool_p.h" #include "qdeadlinetimer.h" #include "qcoreapplication.h" +#include <QtCore/qpointer.h> + #include <algorithm> +#include <memory> QT_BEGIN_NAMESPACE +using namespace Qt::StringLiterals; + /* QThread wrapper, provides synchronization against a ThreadPool */ @@ -112,16 +81,15 @@ void QThreadPoolThread::run() locker.relock(); } - // if too many threads are active, expire this thread + // if too many threads are active, stop working in this one if (manager->tooManyThreadsActive()) break; - if (manager->queue.isEmpty()) { - r = nullptr; + // all work is done, time to wait for more + if (manager->queue.isEmpty()) break; - } - QueuePage *page = manager->queue.first(); + QueuePage *page = manager->queue.constFirst(); r = page->pop(); if (page->isFinished()) { @@ -130,26 +98,32 @@ void QThreadPoolThread::run() } } while (true); - // if too many threads are active, expire this thread - bool expired = manager->tooManyThreadsActive(); - if (!expired) { - manager->waitingThreads.enqueue(this); + // this thread is about to be deleted, do not wait or expire + if (!manager->allThreads.contains(this)) { registerThreadInactive(); - // wait for work, exiting after the expiry timeout is reached - runnableReady.wait(locker.mutex(), QDeadlineTimer(manager->expiryTimeout)); - ++manager->activeThreads; - if (manager->waitingThreads.removeOne(this)) - expired = true; - if (!manager->allThreads.contains(this)) { - registerThreadInactive(); - break; - } + return; } - if (expired) { + + // if too many threads are active, expire this thread + if (manager->tooManyThreadsActive()) { manager->expiredThreads.enqueue(this); registerThreadInactive(); - break; + return; + } + manager->waitingThreads.enqueue(this); + registerThreadInactive(); + // wait for work, exiting after the expiry timeout is reached + runnableReady.wait(locker.mutex(), QDeadlineTimer(manager->expiryTimeout)); + // this thread is about to be deleted, do not work or expire + if (!manager->allThreads.contains(this)) { + Q_ASSERT(manager->queue.isEmpty()); + return; } + if (manager->waitingThreads.removeOne(this)) { + manager->expiredThreads.enqueue(this); + return; + } + ++manager->activeThreads; } } @@ -176,10 +150,10 @@ bool QThreadPoolPrivate::tryStart(QRunnable *task) } // can't do anything if we're over the limit - if (activeThreadCount() >= maxThreadCount()) + if (areAllThreadsActive()) return false; - if (waitingThreads.count() > 0) { + if (!waitingThreads.isEmpty()) { // recycle an available thread enqueueTask(task); waitingThreads.takeFirst()->runnableReady.wakeOne(); @@ -216,7 +190,7 @@ inline bool comparePriority(int priority, const QueuePage *p) void QThreadPoolPrivate::enqueueTask(QRunnable *runnable, int priority) { Q_ASSERT(runnable != nullptr); - for (QueuePage *page : qAsConst(queue)) { + for (QueuePage *page : std::as_const(queue)) { if (page->priority() == priority && !page->isFull()) { page->push(runnable); return; @@ -228,9 +202,9 @@ void QThreadPoolPrivate::enqueueTask(QRunnable *runnable, int priority) int QThreadPoolPrivate::activeThreadCount() const { - return (allThreads.count() - - expiredThreads.count() - - waitingThreads.count() + return (allThreads.size() + - expiredThreads.size() + - waitingThreads.size() + reservedThreads); } @@ -238,7 +212,7 @@ void QThreadPoolPrivate::tryToStartMoreThreads() { // try to push tasks on the queue to any available threads while (!queue.isEmpty()) { - QueuePage *page = queue.first(); + QueuePage *page = queue.constFirst(); if (!tryStart(page->first())) break; @@ -251,6 +225,12 @@ void QThreadPoolPrivate::tryToStartMoreThreads() } } +bool QThreadPoolPrivate::areAllThreadsActive() const +{ + const int activeThreadCount = this->activeThreadCount(); + return activeThreadCount >= maxThreadCount() && (activeThreadCount - reservedThreads) >= 1; +} + bool QThreadPoolPrivate::tooManyThreadsActive() const { const int activeThreadCount = this->activeThreadCount(); @@ -262,39 +242,37 @@ bool QThreadPoolPrivate::tooManyThreadsActive() const */ void QThreadPoolPrivate::startThread(QRunnable *runnable) { - Q_Q(QThreadPool); Q_ASSERT(runnable != nullptr); - QScopedPointer<QThreadPoolThread> thread(new QThreadPoolThread(this)); - QString objectName; - if (QString myName = q->objectName(); !myName.isEmpty()) - objectName = myName; - else - objectName = QLatin1String("Thread (pooled)"); + auto thread = std::make_unique<QThreadPoolThread>(this); + if (objectName.isEmpty()) + objectName = u"Thread (pooled)"_s; thread->setObjectName(objectName); - Q_ASSERT(!allThreads.contains(thread.data())); // if this assert hits, we have an ABA problem (deleted threads don't get removed here) - allThreads.insert(thread.data()); + Q_ASSERT(!allThreads.contains(thread.get())); // if this assert hits, we have an ABA problem (deleted threads don't get removed here) + allThreads.insert(thread.get()); ++activeThreads; thread->runnable = runnable; - thread.take()->start(threadPriority); + thread.release()->start(threadPriority); } /*! \internal Helper function only to be called from waitForDone(int) + + Deletes all current threads. */ void QThreadPoolPrivate::reset() { // move the contents of the set out so that we can iterate without the lock - QSet<QThreadPoolThread *> allThreadsCopy; - allThreadsCopy.swap(allThreads); + auto allThreadsCopy = std::exchange(allThreads, {}); expiredThreads.clear(); waitingThreads.clear(); + mutex.unlock(); - for (QThreadPoolThread *thread : qAsConst(allThreadsCopy)) { - if (!thread->isFinished()) { + for (QThreadPoolThread *thread : std::as_const(allThreadsCopy)) { + if (thread->isRunning()) { thread->runnableReady.wakeAll(); thread->wait(); } @@ -321,15 +299,13 @@ bool QThreadPoolPrivate::waitForDone(int msecs) { QMutexLocker locker(&mutex); QDeadlineTimer timer(msecs); - do { - if (!waitForDone(timer)) - return false; - reset(); - // More threads can be started during reset(), in that case continue - // waiting if we still have time left. - } while ((!queue.isEmpty() || activeThreads) && !timer.hasExpired()); - - return queue.isEmpty() && activeThreads == 0; + if (!waitForDone(timer)) + return false; + reset(); + // New jobs might have started during reset, but return anyway + // as the active thread and task count did reach 0 once, and + // race conditions are outside our scope. + return true; } void QThreadPoolPrivate::clear() @@ -374,7 +350,7 @@ bool QThreadPool::tryTake(QRunnable *runnable) return false; QMutexLocker locker(&d->mutex); - for (QueuePage *page : qAsConst(d->queue)) { + for (QueuePage *page : std::as_const(d->queue)) { if (page->tryTake(runnable)) { if (page->isFinished()) { d->queue.removeOne(page); @@ -416,7 +392,7 @@ void QThreadPoolPrivate::stealAndRunRunnable(QRunnable *runnable) \ingroup thread - QThreadPool manages and recyles individual QThread objects to help reduce + QThreadPool manages and recycles 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(). @@ -465,7 +441,14 @@ void QThreadPoolPrivate::stealAndRunRunnable(QRunnable *runnable) */ QThreadPool::QThreadPool(QObject *parent) : QObject(*new QThreadPoolPrivate, parent) -{ } +{ + Q_D(QThreadPool); + connect(this, &QObject::objectNameChanged, this, [d](const QString &newName) { + // We keep a copy of the name under our own lock, so we can access it thread-safely. + QMutexLocker locker(&d->mutex); + d->objectName = newName; + }); +} /*! Destroys the QThreadPool. @@ -473,7 +456,10 @@ QThreadPool::QThreadPool(QObject *parent) */ QThreadPool::~QThreadPool() { + Q_D(QThreadPool); waitForDone(); + Q_ASSERT(d->queue.isEmpty()); + Q_ASSERT(d->allThreads.isEmpty()); } /*! @@ -481,8 +467,8 @@ QThreadPool::~QThreadPool() */ QThreadPool *QThreadPool::globalInstance() { - static QPointer<QThreadPool> theInstance; - static QBasicMutex theMutex; + Q_CONSTINIT static QPointer<QThreadPool> theInstance; + Q_CONSTINIT static QBasicMutex theMutex; const QMutexLocker locker(&theMutex); if (theInstance.isNull() && !QCoreApplication::closingDown()) @@ -491,6 +477,21 @@ QThreadPool *QThreadPool::globalInstance() } /*! + Returns the QThreadPool instance for Qt Gui. + \internal +*/ +QThreadPool *QThreadPoolPrivate::qtGuiInstance() +{ + Q_CONSTINIT static QPointer<QThreadPool> guiInstance; + Q_CONSTINIT static QBasicMutex theMutex; + + const QMutexLocker locker(&theMutex); + if (guiInstance.isNull() && !QCoreApplication::closingDown()) + guiInstance = new QThreadPool(); + return guiInstance; +} + +/*! Reserves a thread and uses it to run \a runnable, unless this thread will make the current thread count exceed maxThreadCount(). In that case, \a runnable is added to a run queue instead. The \a priority argument can @@ -513,29 +514,26 @@ void QThreadPool::start(QRunnable *runnable, int priority) Q_D(QThreadPool); QMutexLocker locker(&d->mutex); - if (!d->tryStart(runnable)) { + if (!d->tryStart(runnable)) d->enqueueTask(runnable, priority); - - if (!d->waitingThreads.isEmpty()) - d->waitingThreads.takeFirst()->runnableReady.wakeOne(); - } } /*! + \fn template<typename Callable, QRunnable::if_callable<Callable>> void QThreadPool::start(Callable &&callableToRun, int priority) \overload \since 5.15 - Reserves a thread and uses it to run \a functionToRun, unless this thread will + Reserves a thread and uses it to run \a callableToRun, unless this thread will make the current thread count exceed maxThreadCount(). In that case, - \a functionToRun is added to a run queue instead. The \a priority argument can + \a callableToRun is added to a run queue instead. The \a priority argument can be used to control the run queue's order of execution. + + \note This function participates in overload resolution only if \c Callable + is a function or function object which can be called with zero arguments. + + \note In Qt version prior to 6.6, this function took std::function<void()>, + and therefore couldn't handle move-only callables. */ -void QThreadPool::start(std::function<void()> functionToRun, int priority) -{ - if (!functionToRun) - return; - start(QRunnable::create(std::move(functionToRun)), priority); -} /*! Attempts to reserve a thread to run \a runnable. @@ -567,30 +565,21 @@ bool QThreadPool::tryStart(QRunnable *runnable) } /*! + \fn template<typename Callable, QRunnable::if_callable<Callable>> bool QThreadPool::tryStart(Callable &&callableToRun) \overload \since 5.15 - Attempts to reserve a thread to run \a functionToRun. + Attempts to reserve a thread to run \a callableToRun. If no threads are available at the time of calling, then this function - does nothing and returns \c false. Otherwise, \a functionToRun is run immediately + does nothing and returns \c false. Otherwise, \a callableToRun is run immediately using one available thread and this function returns \c true. -*/ -bool QThreadPool::tryStart(std::function<void()> functionToRun) -{ - if (!functionToRun) - return false; - Q_D(QThreadPool); - QMutexLocker locker(&d->mutex); - if (!d->allThreads.isEmpty() && d->activeThreadCount() >= d->maxThreadCount()) - return false; + \note This function participates in overload resolution only if \c Callable + is a function or function object which can be called with zero arguments. - QRunnable *runnable = QRunnable::create(std::move(functionToRun)); - if (d->tryStart(runnable)) - return true; - delete runnable; - return false; -} + \note In Qt version prior to 6.6, this function took std::function<void()>, + and therefore couldn't handle move-only callables. +*/ /*! \property QThreadPool::expiryTimeout \brief the thread expiry timeout value in milliseconds. @@ -610,12 +599,14 @@ bool QThreadPool::tryStart(std::function<void()> functionToRun) int QThreadPool::expiryTimeout() const { Q_D(const QThreadPool); + QMutexLocker locker(&d->mutex); return d->expiryTimeout; } void QThreadPool::setExpiryTimeout(int expiryTimeout) { Q_D(QThreadPool); + QMutexLocker locker(&d->mutex); if (d->expiryTimeout == expiryTimeout) return; d->expiryTimeout = expiryTimeout; @@ -636,6 +627,7 @@ void QThreadPool::setExpiryTimeout(int expiryTimeout) int QThreadPool::maxThreadCount() const { Q_D(const QThreadPool); + QMutexLocker locker(&d->mutex); return d->requestedMaxThreadCount; } @@ -674,7 +666,10 @@ int QThreadPool::activeThreadCount() const 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. + \note Even if reserving maxThreadCount() threads or more, the thread pool + will still allow a minimum of one thread. + + \note This function will increase the reported number of active threads. This means that by using this function, it is possible for activeThreadCount() to return a value greater than maxThreadCount() . @@ -702,12 +697,14 @@ void QThreadPool::reserveThread() void QThreadPool::setStackSize(uint stackSize) { Q_D(QThreadPool); + QMutexLocker locker(&d->mutex); d->stackSize = stackSize; } uint QThreadPool::stackSize() const { Q_D(const QThreadPool); + QMutexLocker locker(&d->mutex); return d->stackSize; } @@ -728,12 +725,14 @@ uint QThreadPool::stackSize() const void QThreadPool::setThreadPriority(QThread::Priority priority) { Q_D(QThreadPool); + QMutexLocker locker(&d->mutex); d->threadPriority = priority; } QThread::Priority QThreadPool::threadPriority() const { Q_D(const QThreadPool); + QMutexLocker locker(&d->mutex); return d->threadPriority; } @@ -758,6 +757,57 @@ void QThreadPool::releaseThread() } /*! + Releases a thread previously reserved with reserveThread() and uses it + to run \a runnable. + + Note that the thread pool takes ownership of the \a runnable if + \l{QRunnable::autoDelete()}{runnable->autoDelete()} returns \c true, + and the \a runnable will be deleted automatically by the thread + pool after the \l{QRunnable::run()}{runnable->run()} returns. If + \l{QRunnable::autoDelete()}{runnable->autoDelete()} returns \c false, + ownership of \a runnable remains with the caller. Note that + changing the auto-deletion on \a runnable after calling this + functions results in undefined behavior. + + \note Calling this when no threads are reserved results in + undefined behavior. + + \since 6.3 + \sa reserveThread(), start() +*/ +void QThreadPool::startOnReservedThread(QRunnable *runnable) +{ + if (!runnable) + return releaseThread(); + + Q_D(QThreadPool); + QMutexLocker locker(&d->mutex); + Q_ASSERT(d->reservedThreads > 0); + --d->reservedThreads; + + if (!d->tryStart(runnable)) { + // This can only happen if we reserved max threads, + // and something took the one minimum thread. + d->enqueueTask(runnable, INT_MAX); + } +} + +/*! + \fn template<typename Callable, QRunnable::if_callable<Callable>> void QThreadPool::startOnReservedThread(Callable &&callableToRun) + \overload + \since 6.3 + + Releases a thread previously reserved with reserveThread() and uses it + to run \a callableToRun. + + \note This function participates in overload resolution only if \c Callable + is a function or function object which can be called with zero arguments. + + \note In Qt version prior to 6.6, this function took std::function<void()>, + and therefore couldn't handle move-only callables. +*/ + +/*! Waits up to \a msecs milliseconds for all threads to exit and removes all threads from the thread pool. Returns \c true if all threads were removed; otherwise it returns \c false. If \a msecs is -1 (the default), the timeout |