qthreadpool_p.h

Go to the documentation of this file.

// 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
// Qt-Security score:significant reason:default
 
#ifndef QTHREADPOOL_P_H
#define QTHREADPOOL_P_H
 
//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API.  It exists purely as an
// implementation detail.  This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
//
 
#include "QtCore/qmutex.h"
#include "QtCore/qthread.h"
#include "QtCore/qwaitcondition.h"
#include "QtCore/qthreadpool.h"
#include "QtCore/qset.h"
#include "QtCore/qqueue.h"
#include "private/qobject_p.h"
 
QT_BEGIN_NAMESPACE
 
class QDeadlineTimer;
 
class QThreadPoolThread;
class QThreadPoolPrivate : public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QThreadPool)
    friend class QThreadPoolThread;
 
public:
    struct QueuePage
    {
        enum {
            MaxPageSize = 256
        };
 
        QueuePage(QRunnable *runnable, int pri) : m_priority(pri) { push(runnable); }
 
        bool isFull() { return m_lastIndex >= MaxPageSize - 1; }
 
        bool isFinished() { return m_firstIndex > m_lastIndex; }
 
        void push(QRunnable *runnable)
        {
            Q_ASSERT(runnable != nullptr);
            Q_ASSERT(!isFull());
            m_lastIndex += 1;
            m_entries[m_lastIndex] = runnable;
        }
 
        void skipToNextOrEnd()
        {
            while (!isFinished() && m_entries[m_firstIndex] == nullptr) {
                m_firstIndex += 1;
            }
        }
 
        QRunnable *first()
        {
            Q_ASSERT(!isFinished());
            QRunnable *runnable = m_entries[m_firstIndex];
            Q_ASSERT(runnable);
            return runnable;
        }
 
        QRunnable *pop()
        {
            Q_ASSERT(!isFinished());
            QRunnable *runnable = first();
            Q_ASSERT(runnable);
 
            // clear the entry although this should not be necessary
            m_entries[m_firstIndex] = nullptr;
            m_firstIndex += 1;
 
            // make sure the next runnable returned by first() is not a nullptr
            skipToNextOrEnd();
 
            return runnable;
        }
 
        bool tryTake(QRunnable *runnable)
        {
            Q_ASSERT(!isFinished());
            for (int i = m_firstIndex; i <= m_lastIndex; i++) {
                if (m_entries[i] == runnable) {
                    m_entries[i] = nullptr;
                    if (i == m_firstIndex) {
                        // make sure first() does not return a nullptr
                        skipToNextOrEnd();
                    }
                    return true;
                }
            }
            return false;
        }
 
        int priority() const { return m_priority; }
 
    private:
        int m_priority = 0;
        int m_firstIndex = 0;
        int m_lastIndex = -1;
        QRunnable *m_entries[MaxPageSize];
    };
 
    QThreadPoolPrivate();
    static void destroyGlobalThreadPool();
 
    bool tryStart(QRunnable *task);
    void enqueueTask(QRunnable *task, int priority = 0);
    int activeThreadCount() const;
 
    void tryToStartMoreThreads();
    bool areAllThreadsActive() const;
    bool tooManyThreadsActive() const;
 
    int maxThreadCount() const
    { return qMax(requestedMaxThreadCount, 1); }    // documentation says we start at least one
    void startThread(QRunnable *runnable = nullptr);
    void reset();
    bool waitForDone(const QDeadlineTimer &timer);
    void clear();
    void stealAndRunRunnable(QRunnable *runnable);
    void deletePageIfFinished(QueuePage *page);
 
    mutable QMutex mutex;
    QSet<QThreadPoolThread *> allThreads;
    QQueue<QThreadPoolThread *> waitingThreads;
    QQueue<QThreadPoolThread *> expiredThreads;
    QList<QueuePage *> queue;
    QWaitCondition noActiveThreads;
    QString objectName;
 
    std::chrono::duration<int, std::milli> expiryTimeout = std::chrono::seconds(30);
    int requestedMaxThreadCount = QThread::idealThreadCount();  // don't use this directly
    int reservedThreads = 0;
    int activeThreads = 0;
    uint stackSize = 0;
    QThread::Priority threadPriority = QThread::InheritPriority;
    QThread::QualityOfService serviceLevel = QThread::QualityOfService::Auto;
};
 
QT_END_NAMESPACE
 
#endif