Qt线程：QThread

一、描述

一个QThread对象管理程序内的一个线程，QThreads在run()中开始执行。默认情况下，run()通过调用exec()启动事件循环，并在线程内部运行一个Qt事件循环。

可以通过使用 QObject::moveToThread() 将对象移动到线程来使用它们。

 class Worker : public QObject
 {
     Q_OBJECT

 public slots:
     void doWork(const QString &parameter)
     {
         QString result;
         /* ... 这里是昂贵的或阻塞的操作 ... * /
         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 &);
 };

Worker 槽内的代码将在单独的线程中执行。可以自由地将 Worker 槽连接到来自任何对象、任何线程中的任何信号。跨不同线程连接信号和槽是安全的。

另一种使代码在单独线程中运行的方法是将 QThread 子类化并重新实现 run()。例如：

 class WorkerThread : public QThread
 {
     Q_OBJECT
     void run() override 
     {
         QString result;
         /* ... 这里是昂贵的或阻塞的操作 ... * /
         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();
 }

示例中，线程将在 run 函数返回后退出。除非调用 exec()，否则线程中不会运行任何事件循环。

QThread 实例除了run()函数在新线程中执行，其他所有函数都在QThread 实例所在的线程中执行。这样可能会则从两个不同的线程访问同一个成员变量变量，要注意检查这样做是否安全。

---

二、类型成员

1、enum QThread::Priority：此枚举类型指示操作系统应如何调度新创建的线程。

• IdlePriority：仅当没有其他线程正在运行时才调度。
• LowestPriority：调度频率低于 LowPriority。
• LowPriority：调度频率低于 NormalPriority。
• NormalPriority：操作系统的默认优先级。
• HighPriority：比 NormalPriority 更频繁地调度。
• HighestPriority：比 HighPriority 更频繁地调度。
• TimeCriticalPriority：尽可能经常安排调度。
• InheritPriority：使用与创建线程相同的优先级。这是默认设置。

---

三、成员函数

1、[signal] void finished()

该信号在线程完成执行之前发出。当这个信号发出时，事件循环已经停止运行。除了延迟删除事件外，线程中将不再处理更多事件。该信号可以连接到 QObject::deleteLater()，以释放该线程中的对象。

注意：这是私有信号。 它可以用于信号连接，但不能由用户发射。

 2、void quit()

告诉线程的事件循环以返回码 0（成功）退出。 相当于调用 exit(0)。如果线程没有事件循环，则此函数不执行任何操作。此函数是线程安全的。

3、void start(QThread::Priority priority = InheritPriority)

通过调用 run() 开始执行线程。 操作系统会根据参数中设置的优先级调度线程。如果线程已经在运行，这个函数什么都不做。

优先级参数的效果取决于操作系统的调度策略。在不支持线程优先级的系统上，优先级将被忽略（如 Linux系统 ）。

4、[signal] void started()

当相关线程开始执行时，在调用 run() 函数之前，该信号从相关线程发出。这是私有信号，可以用于信号连接，但不能由用户发射。

5、void terminate()

终止线程的执行。线程可能会也可能不会立即终止，这取决于操作系统的调度策略。确保在terminate()之后调用 wait()。

当线程终止时，所有等待线程完成的线程都会被唤醒。

警告：此功能很危险，不鼓励使用。线程可能在其代码路径中的任何一点终止。修改数据时可能终止线程，线程将没有机会自行清理，解锁任何持有的互斥锁等。简而言之，只有在绝对必要时才使用此功能。

可以通过调用 setTerminationEnabled() 显式启用或禁用终止。在禁用终止时调用此函数会导致终止被推迟，直到重新启用终止。

6、~QThread()

销毁线程。删除 QThread 对象不会停止它管理的线程的执行。删除正在运行的 QThread将导致程序崩溃。应在删除 QThread 之前等待finished()信号。

7、[static] QThread *create(Function &&f, Args &&... args)

      [static] QThread *create(Function &&f)

创建一个新的 QThread 对象，该对象将使用参数 args 执行函数 f。

新线程没有启动，它必须通过显式调用 start() 启动。

注意：此函数仅在使用 C++17 时可用。

警告：不要在返回的 QThread 实例上多次调用 start()， 这样做会导致未定义的行为。

例：

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    int i = 0;
    QThread * t = QThread::create([i]()mutable
    {
        while(i < 3)
        {
            qDebug()<<i;
            ++i;
        }
        qDebug()<<"lambda创建的子线程ID："<<QThread::currentThreadId();
    });
    QObject::connect(t,&QThread::finished,[t]
    {
        qDebug()<<"线程是否仍在运行："<<t->isRunning();
        t->deleteLater();
    });
    qDebug()<<"主线程ID："<<QThread::currentThreadId();
    t->start();
}

 8、[static] QThread *currentThread()

返回指向当前执行线程的指针。

9、[static] Qt::HANDLE currentThreadId() 

返回当前正在执行的线程的线程句柄。警告：此函数返回的句柄用于内部目的，不应在任何应用程序代码中使用。

10、int exec()

进入事件循环并等待 exit() 被调用，返回传递给 exit() 的值。如果 exit() 是通过 quit() 调用的，则返回的值为 0。此函数从 run() 内部调用。需要调用这个函数来启动事件处理。

11、void exit(int returnCode = 0)

线程的事件循环以返回码returnCode 退出。

调用此函数后，线程离开事件循环并从对 QEventLoop::exec() 的调用返回。QEventLoop::exec() 函数返回 returnCode。

按照惯例，returnCode 为 0 表示成功，任何非零值表示错误。

12、[static] int idealThreadCount()

返回可以在系统上运行的理想线程数。这是通过查询系统中的实际和逻辑处理器内核数量来完成的。 如果无法检测到处理器内核数，则此函数返回 1。

13、bool isInterruptionRequested()

如果应停止在此线程上运行的任务，则返回 true。 requestInterruption() 可以请求中断。

此函数可用于使长时间运行的任务完全可中断。注意不要太频繁地调用它，以保持低开销。只能在线程本身内调用。

在长时间执行的任务中加上这个判断。如果有很消耗资源的情况可以中断线程。

14、void requestInterruption()

请求中断线程。该请求是建议性的，由线程上运行的代码决定是否以及如何应对此类请求。此函数不会停止在线程上运行的事件循环。

15、int loopLevel()

返回线程的当前事件循环级别。只能在线程本身内调用，即当它是当前线程时。

16、[static] void msleep(unsigned long msecs) （毫秒）

        [static] void sleep(unsigned long secs) （秒）

        [static] void usleep(unsigned long usecs) （微秒）

强制当前线程休眠。如果需要等待某个条件的达成，则应避免使用此函数改用信号槽。此功能不保证准确性。

17、void run()

线程的起点。调用 start() 后，新创建的线程调用此函数。默认实现只是调用 exec()。可以重新实现此功能以自定义线程操作。从此方法返回将结束线程的执行。

18、void setEventDispatcher(QAbstractEventDispatcher *eventDispatcher)

设置线程的事件调度程序。在使用 start() 启动线程之前，或者在主线程的情况下，在实例化 QCoreApplication 之前调用才有效。

19、void setStackSize(uint stackSize)

将线程的最大堆栈大小设置为 stackSize。 如果 stackSize 大于零，则最大堆栈大小设置为 stackSize 字节，否则最大堆栈大小由操作系统自动确定。

警告：大多数操作系统对线程堆栈大小设置了最小和最大限制。 如果堆栈大小超出这些限制，线程将无法启动。

20、[static protected] void setTerminationEnabled(bool enabled = true)

启用或禁用当前线程的终止。该线程必须已由 QThread 启动。

当 enabled 为 false 时，终止被禁用。以后对 terminate() 的调用将不会生效。直到设置setTerminationEnabled(true)时才会生效。
当 enabled 为 true 时，终止被启用。以后对 terminate() 的调用将正常终止线程。

21、bool wait(QDeadlineTimer deadline = QDeadlineTimer(QDeadlineTimer::Forever))

        bool wait(unsigned long time)

阻塞当前调用QThread对象的线程，直到满足以下任一条件：

• QThread对象关联的线程已完成执行（即当它从 run() 返回时）。如果线程已完成执行，此函数将返回 true。如果线程尚未启动，它也会返回 true。
• 截止时间已到。如果达到最后期限，此函数将返回 false（线程还在继续执行）。

设置为 QDeadlineTimer::Forever（默认值）的截止时间计时器永远不会超时，在这种情况下，该函数仅在线程从 run() 返回或线程尚未启动时返回。

class myThread : public QThread
{
public:
    myThread(){}
protected:
    void run()override
    {
        int n = 0;
        for(int i = 0;i < 2000000000;++i)
        {
            if(i % 266 == 0)
                ++n;
        }
        qDebug()<<"n = "<<n;
    }
};

int main(int argc, char *argv[])
{
    QApplication a(argc,argv);
    myThread thread;
    thread.start();
    qDebug()<<thread.wait(1000);
    qDebug()<<"runing";
    Widget w;
    w.show();
    a.exec();
}

 22、[static] void yieldCurrentThread()

将当前线程的执行交给另一个可运行线程（如果有）。操作系统决定切换到哪个线程。