QThread露

PyQt5.QtCore.QThread: Inherits from QObject.

Description露

The QThread class provides a platform-independent way to manage threads.

A QThread object manages one thread of control within the program. QThreads begin executing in run(). By default, run() starts the event loop by calling exec() and runs a Qt event loop inside the thread.

You can use worker objects by moving them to the thread using moveToThread().

# class Worker : public QObject
# {
#     Q_OBJECT

# public slots:
#     void doWork(const QString &parameter) {
#         QString result;
#         /* ... here is the expensive or blocking operation ... */
#         emit resultReady(result);
#     }

# signals:
#     void resultReady(const QString &result);
# };

# class Controller : public QObject
# {
#     Q_OBJECT
#     QThread workerThread;
# public:
#     Controller() {
#         Worker *worker = new Worker;
#         worker->moveToThread(&workerThread);
#         connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);
#         connect(this, &Controller::operate, worker, &Worker::doWork);
#         connect(worker, &Worker::resultReady, this, &Controller::handleResults);
#         workerThread.start();
#     }
#     ~Controller() {
#         workerThread.quit();
#         workerThread.wait();
#     }
# public slots:
#     void handleResults(const QString &);
# signals:
#     void operate(const QString &);
# };

The code inside the Worker鈥檚 slot would then execute in a separate thread. However, you are free to connect the Worker鈥檚 slots to any signal, from any object, in any thread. It is safe to connect signals and slots across different threads, thanks to a mechanism called QueuedConnection.

Another way to make code run in a separate thread, is to subclass QThread and reimplement run(). For example:

# class WorkerThread : public QThread
# {
#     Q_OBJECT
#     void run() override {
#         QString result;
#         /* ... here is the expensive or blocking operation ... */
#         emit resultReady(result);
#     }
# signals:
#     void resultReady(const QString &s);
# };

# void MyObject::startWorkInAThread()
# {
#     WorkerThread *workerThread = new WorkerThread(this);
#     connect(workerThread, &WorkerThread::resultReady, this, &MyObject::handleResults);
#     connect(workerThread, &WorkerThread::finished, workerThread, &QObject::deleteLater);
#     workerThread->start();
# }

In that example, the thread will exit after the run function has returned. There will not be any event loop running in the thread unless you call exec().

It is important to remember that a QThread instance lives in the old thread that instantiated it, not in the new thread that calls run(). This means that all of QThread鈥檚 queued slots and invokeMethod() will execute in the old thread. Thus, a developer who wishes to invoke slots in the new thread must use the worker-object approach; new slots should not be implemented directly into a subclassed QThread.

Unlike queued slots or invoked methods, methods called directly on the QThread object will execute in the thread that calls the method. When subclassing QThread, keep in mind that the constructor executes in the old thread while run() executes in the new thread. If a member variable is accessed from both functions, then the variable is accessed from two different threads. Check that it is safe to do so.

Note: Care must be taken when interacting with objects across different threads. See Synchronizing Threads for details.

Managing Threads露

QThread will notifiy you via a signal when the thread is started and finished, or you can use isFinished() and isRunning() to query the state of the thread.

You can stop the thread by calling exit() or quit(). In extreme cases, you may want to forcibly terminate() an executing thread. However, doing so is dangerous and discouraged. Please read the documentation for terminate() and setTerminationEnabled() for detailed information.

From Qt 4.8 onwards, it is possible to deallocate objects that live in a thread that has just ended, by connecting the finished signal to deleteLater().

Use wait() to block the calling thread, until the other thread has finished execution (or until a specified time has passed).

QThread also provides static, platform independent sleep functions: sleep(), msleep(), and usleep() allow full second, millisecond, and microsecond resolution respectively. These functions were made public in Qt 5.0.

Note: wait() and the sleep() functions should be unnecessary in general, since Qt is an event-driven framework. Instead of wait(), consider listening for the finished signal. Instead of the sleep() functions, consider using QTimer.

The static functions currentThreadId() and currentThread() return identifiers for the currently executing thread. The former returns a platform specific ID for the thread; the latter returns a QThread pointer.

To choose the name that your thread will be given (as identified by the command ps -L on Linux, for example), you can call setObjectName() before starting the thread. If you don鈥檛 call setObjectName(), the name given to your thread will be the class name of the runtime type of your thread object (for example, "RenderThread" in the case of the Mandelbrot Example, as that is the name of the QThread subclass). Note that this is currently not available with release builds on Windows.

Enums露

Priority

This enum type indicates how the operating system should schedule newly created threads.

Member	Value	Description
HighestPriority	5	scheduled more often than .
HighPriority	4	scheduled more often than .
IdlePriority	0	scheduled only when no other threads are running.
InheritPriority	7	use the same priority as the creating thread. This is the default.
LowestPriority	1	scheduled less often than .
LowPriority	2	scheduled less often than .
NormalPriority	3	the default priority of the operating system.
TimeCriticalPriority	6	scheduled as often as possible.

Methods露

__init__(parent: QObject = None): TODO

@staticmethod currentThread() → QThread: TODO

@staticmethod currentThreadId() → sip.voidptr: TODO

event(QEvent) → bool: TODO

eventDispatcher() → QAbstractEventDispatcher: TODO

exec() → int: TODO

exec_() → int: TODO

exit(returnCode: int = 0): TODO

@staticmethod idealThreadCount() → int: TODO

isFinished() → bool: TODO

isInterruptionRequested() → bool: TODO

isRunning() → bool: TODO

loopLevel() → int: TODO

@staticmethod msleep(int): TODO

priority() → Priority: See also

setPriority().

quit(): TODO

requestInterruption(): TODO

run(): TODO

setEventDispatcher(QAbstractEventDispatcher): TODO

setPriority(Priority): See also

priority().

setStackSize(int): See also

stackSize().

@staticmethod setTerminationEnabled(enabled: bool = True): TODO

@staticmethod sleep(int): TODO

stackSize() → int: See also

setStackSize().

start(priority: Priority = InheritPriority): TODO

terminate(): TODO

@staticmethod usleep(int): TODO

wait(msecs: int = ULONG_MAX) → bool: TODO

@staticmethod yieldCurrentThread(): TODO

Signals露

finished(): TODO

started(): TODO