QThread 的两种使用方法

1. 不使用事件循环。这是官方的 Manual 、example 以及相关书籍中都介绍的一种的方法。

a. 子类化 QThread
b. 重载 run 函数，run函数内有一个 while 或 for 的死循环
c. 设置一个标记为来控制死循环的退出。

2. 使用事件循环。（博客 you are-doing-it-wrong 批驳的就是这种情况下的 一种用法。）

a. 子类化 QThread，
b. 重载 run 使其调用 QThread::exec()
c. 并为该类定义信号和槽，这样一来，由于槽函数并不会在新开的 thread 运行，很多人为了解决这个问题在构造函数中调用  moveToThread(this)
而争论和不解正是这样的一条语句造成的。
Bradley T. Hughes 给出说明是： QThread 应该被看做是操作系统线程的接口或控制点，而不应该包含需要在新线程中运行的代码。需要运行的代码应该放到一个QObject的子类中，然后将该子类的对象moveToThread到新线程中。

另外

在Qt4.3(包括)之前，run 是虚函数，必须子类化QThread来实现run函数。

而从Qt4.4开始，qthreads-no-longer-abstract ，run 默认调用 QThread::exec() 。这样一来不需要子类化 QThread 了，只需要子类化一个 QObject 就够了，这正是被 Bradley T. Hughes推荐的方法。终于看懂了，但不管怎么说，都应该是 QThread 当初的设计导致的这种问题，而所有文档和例子中都没有提到该如何使用Qthread 进一步加剧了对QThread的这种误用。

---

QThread 使用探讨

QThread 似乎是很难的一个东西，特别是信号和槽，有非常多的人(尽管使用者本人往往不知道)在用不恰当(甚至错误)的方式在使用 QThread，随便用google一搜，就能搜出大量结果出来。无怪乎Qt的开发人员 Bradley T. Hughes 声嘶力竭地喊you are-doing-it-wrong。

和众多用户一样，初次看到这个时，感到 Bradley T. Hughes有 些莫名奇妙，小题大作。尽管不舒服，当时还是整理过一篇博客QThread 的使用方法

时间过去3个月，尽管依然没怎么用thread；但今天csdn论坛中有人问到这个问题，想想还是尽我所能整理一下吧。提升自己，方便他人，何乐而不为呢?

QThread东西还是比较多的，而且我对底层对象了解有限，仅就一点进行展开(或许是大家最关心的一点)：QThread中的slots在那个线程中执行？

QThread::run

run 函数是做什么用的？Manual中说的清楚：

• run 对于线程的作用相当于main函数对于应用程序。它是线程的入口，run的开始和结束意味着线程的开始和结束。

原文如下(这段话我们称为定理一吧)：

• The run() implementation is for a thread what the main() entry point is for the application. All code executed in a call stack that starts in the run() function is executed by the new thread, and the thread finishes when the function returns.

这么短的文字一眼就看完了，可是，这是什么意思呢？又能说明什么问题呢？看段简单代码：

class Thread:public QThread 
{ 
    Q_OBJECT 
public: 
    Thread(QObject* parent=0):QThread(parent){} 
public slots: 
    void slot() { ... } 
signals: 
    void sig(); 
protected: 
    void run() { ...} 
}; 
int main(int argc, char** argv) 
{ 
... 
    Thread thread; 
... 
}

对照前面的定理，run函数中的代码时确定无疑要在次线程中运行的，那么其他的呢？比如 slot 是在次线程还是主线程中运行？

你想说主线程，但又心有不甘，对么？

QObject::connect

涉及信号槽，我们就躲不过 connect 函数，只是这个函数大家太熟悉。我不好意思再用一堆废话来描述它，但不说又不行，那么折中一下，只看它的最后一个参数吧(为了简单起见，只看它最常用的3个值)

下面的列表，我们暂称为定理二:

自动连接(Auto Connection)
这是默认设置
如果信号在接收者所依附的线程内发射，则等同于直接连接
如果发射信号的线程和接受者所依附的线程不同，则等同于队列连接
也就是这说，只存在下面两种情况

直接连接(Direct Connection)
当信号发射时，槽函数将直接被调用。
无论槽函数所属对象在哪个线程，槽函数都在发射信号的线程内执行。

队列连接(Queued Connection)
当控制权回到接受者所依附线程的事件循环时，槽函数被调用。
槽函数在接收者所依附线程执行。

同前面一样，这些文字大家都能看懂。但含义呢？

不妨继续拿前面的例子来看，slot 函数是在主线程还是次线程中执行呢？

定理二强调两个概念：发送信号的线程 和 接收者所依附的线程。而 slot 函数属于我们在main中创建的对象 thread，即thread依附于主线程

队列连接告诉我们：槽函数在接受者所依附线程执行。即 slot 将在主线程执行
直接连接告诉我们：槽函数在发送信号的线程执行。信号在那个线程发送呢？？不定！
自动连接告诉我们：二者不同，等同于队列连接。即 slot 在主线程执行

太绕了？不是么（要彻底理解这几句话，你可能需要看Qt meta-object系统和Qt event系统）

怎么办呢？

如果上两节看不懂，就记住下面的话吧（自己总结的，用词上估计会不太准确）。

QThread 是用来管理线程的，它所依附的线程和它管理的线程并不是同一个东西
QThread 所依附的线程，就是执行 QThread t(0) 或 QThread * t=new QThread(0) 的线程。也就是咱们这儿的主线程
QThread 管理的线程，就是 run 启动的线程。也就是次线程
因为QThread的对象依附在主线程中，所以他的slot函数会在主线程中执行，而不是次线程。除非：
QThread 对象依附到次线程中(通过movetoThread)
slot 和信号是直接连接，且信号在次线程中发射

但上两种解决方法都不好，因为QThread不是这么用的(Bradley T. Hughes)

好了，不再添加更多文字了，看代码，估计咱们都会轻松点

---

主线程(信号)QThread(槽)

这是 Qt Manual 和 例子中普遍采用的方法。 但由于manual没说槽函数是在主线程执行的，所以不少人都认为它应该是在次线程执行了。

定义一个 Dummy 类，用来发信号
定义一个 Thread 类，用来接收信号
重载 run 函数，目的是打印 threadid

/*!
* \file main.cpp
*
* Copyright (C) 2010, dbzhang800
* All rights reserved.
*
*/
#include <QtCore/QCoreApplication> 
#include <QtCore/QObject> 
#include <QtCore/QThread> 
#include <QtCore/QDebug>  
class Dummy:public QObject 
{ 
    Q_OBJECT 
public: 
    Dummy(){} 
public slots: 
    void emitsig() 
    { 
        emit sig(); 
    } 
signals: 
    void sig(); 
}; 
 
class Thread:public QThread 
{ 
    Q_OBJECT 
public: 
    Thread(QObject* parent=0):QThread(parent) 
    { 
        //moveToThread(this); 
    } 
public slots: 
    void slot_main() 
    { 
        qDebug()<<"from thread slot_main:" <<currentThreadId(); 
    } 
protected: 
    void run() 
    { 
        qDebug()<<"thread thread:"<<currentThreadId(); 
        exec(); 
    } 
}; 

#include "main.moc" 

int main(int argc, char *argv[]) 
{  
    QCoreApplication a(argc, argv); 
    qDebug()<<"main thread:"<<QThread::currentThreadId(); 
    Thread thread; 
    Dummy dummy; 
    QObject::connect(&dummy, SIGNAL(sig()), &thread, SLOT(slot_main())); 
    thread.start(); 
    dummy.emitsig(); 
    return a.exec(); 
}

然后看到结果(具体值每次都变，但结论不变)

main thread: 0x1a40 from thread slot_main: 0x1a40 thread thread: 0x1a48

看到了吧，槽函数的线程和主线程是一样的！

如果你看过Qt自带的例子，你会发现 QThread 中 slot 和 run 函数共同操作的对象，都会用QMutex锁住。为什么？

因为slot和run处于不同线程，需要线程间的同步！

如果想让槽函数slot在次线程运行(比如它执行耗时的操作，会让主线程死掉)，怎么解决呢？

注意：dummy信号是在主线程发射的， 接收者 thread 也在主线程中。
参考我们前面的结论，很容易想到:
将 thread 依附的线程改为次线程不就行了？
这也是代码中注释掉的 moveToThread(this)所做的，去掉注释，你会发现slot在次线程中运行

main thread: 0x13c0 
thread thread: 0x1de0 
from thread slot_main: 0x1de0

这可以工作，但这是 Bradley T. Hughes 强烈批判的用法。推荐的方法后面会给出。

run中信号与QThread中槽

定义一个 Dummy 类，在run中发射它的信号
也可以在run中发射 Thread 类中的信号，而不是Dummy（效果完全一样）

QThread 定义槽函数，重载run函数

/*!
* \file main.cpp
*
* Copyright (C) 2010, dbzhang800
* All rights reserved.
*
*/
#include <QtCore/QCoreApplication> 
#include <QtCore/QObject> 
#include <QtCore/QThread> 
#include <QtCore/QDebug> 
 
class Dummy:public QObject 
{ 
    Q_OBJECT 
public: 
    Dummy(QObject* parent=0):QObject(parent){} 
public slots: 
    void emitsig() 
    { 
        emit sig(); 
    } 
signals: 
    void sig(); 
}; 
 
class Thread:public QThread 
{ 
    Q_OBJECT 
public: 
    Thread(QObject* parent=0):QThread(parent) 
    { 
        //moveToThread(this); 
    } 
public slots: 
    void slot_thread() 
    { 
        qDebug()<<"from thread slot_thread:" <<currentThreadId(); 
    } 
signals: 
    void sig(); 
protected: 
    void run() 
    { 
        qDebug()<<"thread thread:"<<currentThreadId(); 
        Dummy dummy; 
        connect(&dummy, SIGNAL(sig()), this, SLOT(slot_thread())); 
        dummy.emitsig(); 
        exec(); 
    } 
}; 
 
#include "main.moc" 
 
int main(int argc, char *argv[]) 
{ 
    QCoreApplication a(argc, argv); 
    qDebug()<<"main thread:"<<QThread::currentThreadId(); 
    Thread thread; 
    thread.start(); 
    return a.exec(); 
}

想看结果么？

main thread: 0x15c0 
thread thread: 0x1750 
from thread slot_thread: 0x15c0

其实没悬念，肯定是主线程
thread 对象本身在主线程。所以它的槽也在要在主线程执行

如何解决呢？

（方法一）前面提了 moveToThread,这儿可以用，而且可以解决问题。当同样，是被批判的对象。
（方法二）注意哦，这儿我们的信号时次线程发出的，对比connect连接方式，会发现：
采用直接连接，槽函数将在次线程(信号发出的线程)执行
这个方法不太好，因为你需要处理slot和它的对象所在线程的同步。需要 QMutex 一类的东西

---

推荐的方法

千呼万唤始出来。 其实，这个方法太简单，太好用了。定义一个普通的QObject派生类，然后将其对象move到QThread中。使用信号和槽时根本不用考虑多线程的存在。也不用使用QMutex来进行同步，Qt的事件循环会自己自动处理好这个。

/*!
* \file main.cpp
*
* Copyright (C) 2010, dbzhang800
* All rights reserved.
*
*/
#include <QtCore/QCoreApplication> 
#include <QtCore/QObject> 
#include <QtCore/QThread> 
#include <QtCore/QDebug> 
 
class Dummy:public QObject 
{ 
    Q_OBJECT 
public: 
    Dummy(QObject* parent=0):QObject(parent)     {} 
public slots: 
    void emitsig() 
    { 
        emit sig(); 
    } 
signals: 
    void sig(); 
}; 
 
class Object:public QObject 
{ 
    Q_OBJECT 
public: 
    Object(){} 
public slots: 
    void slot() 
    { 
        qDebug()<<"from thread slot:" <<QThread::currentThreadId(); 
    } 
}; 
 
#include "main.moc" 
 
int main(int argc, char *argv[]) 
{ 
    QCoreApplication a(argc, argv); 
    qDebug()<<"main thread:"<<QThread::currentThreadId(); 
    QThread thread; 
    Object obj; 
    Dummy dummy; 
    obj.moveToThread(&thread); 
    QObject::connect(&dummy, SIGNAL(sig()), &obj, SLOT(slot())); 
    thread.start(); 
    dummy.emitsig(); 
    return a.exec(); 
}

结果：恩，slot确实不在主线程中运行（这么简单不值得欢呼么？）

main thread: 0x1a5c 
from thread slot: 0x186c

其他

• 本文只考虑了使用事件循环的情况，也有可能run中没有事件循环。这时信号与槽会与本文有点差别。比如run中使用connect时，队列连接就受限制了。其实只要理解了前面这些，没有事件循环的情况很容易就想通了。
• /*********************************************************************

 

Qt 线程（两种QThread类的详细使用方式）

Qt提供QThread类以进行多任务处理。与多任务处理一样，Qt提供的线程可以做到单个线程做不到的事情。例如，网络应用程序中，可以使用线程处理多种连接器。

QThread继承自QObject类，且提供QMutex类以实现同步。线程和进程共享全局变量，可以使用互斥体对改变后的全局变量值实现同步。因此，必须编辑全局数据时，使用互斥体实现同步，其它进程则不能改变或浏览全局变量值。

什么是互斥体？

互斥体实现了“互相排斥”（mutual exclusion）同步的简单形式（所以名为互斥体（mutex））。互斥体禁止多个线程同时进入受保护的代码“临界区”（critical section）。

在任意时刻，只有一个线程被允许进入代码保护区。任何线程在进入临界区之前，必须获取（acquire）与此区域相关联的互斥体的所有权。如果已有另一线程拥有了临界区的互斥体，其他线程就不能再进入其中。这些线程必须等待，直到当前的属主线程释放（release）该互斥体。

什么时候需要使用互斥体呢？

互斥体用于保护共享的易变代码，也就是，全局或静态数据。这样的数据必须通过互斥体进行保护，以防止它们在多个线程同时访问时损坏。

 1 class MyThread : public QThread
 2 {
 3     Q_OBJECT
 4 protected:
 5     void run();
 6 };
 7  
 8 void MyThread :: run(){
 9     ...
10 }

如上述代码所示，如果要创建线程，则必须继承QThread类。MyThread使用成员函数run()才会实现线程。

Qt提供的线程类

线程类 说明
QAtomicInt 提供了Integer上与平台无关的Qtomic运算
QAtomicPointer 提供了指针上Atomic运算的模板函数
QFuture 显示异步运算结果的类
QFutureSynchronizer QFuture类简化同步而提供的类
QFutureWatcher 使用信号和槽，允许QFuture监听
QMutex 访问类之间的同步
QMutecLocker 简化Lock和Unlock Mutex的类
QReadWriteLock 控制读写操作的类
QReadLocker 为了读访问而提供的
QWriteLocker 为了写访问而提供的
QRunnable 正在运行的所有对象的父类，且定义了虚函数run()
QSemaphore 一般的Count互斥体类
QThread 提供与平台无关的线程功能的类
QThreadPool 管理线程的类
QThreadStorage 提供每个线程存储区域的类
QWaitCondition 确认线程间同步的类的状态值

同步QThread的类
为了同步线程，Qt提供了QMutex、QReadWriteLock、QSemaphore和QWaitCondition类。主线程等待与其他线程的中断时，必须进行同步。例如：两个线程同时访问共享变量，那么可能得不到预想的结果。因此，两个线程访问共享变量时，必须进行同步。

一个线程访问指定的共享变量时，为了禁止其他线程访问，QMutex提供了类似锁定装置的功能。互斥体激活状态下，线程不能同时访问共享变量，必须在先访问的线程完成访问后，其他线程才可以继续访问。
一个线程访问互斥体锁定的共享变量期间，如果其他线程也访问此共享变量，那么该线程将会一直处于休眠状态，直到正在访问的线程结束访问。这称为线程安全。
QReadWriteLock和QMutex的功能相同，区别在于，QReadWriteLock对数据的访问分为读访问和写访问。很多线程频繁访问共享变量时，与QMetex相对，使用QReadWriteLock更合适。
QSemaphore拥有和QMutex一样的同步功能，可以管理多个按数字识别的资源。QMutex只能管理一个资源，但如果使用QSemaphore，则可以管理多个按号码识别的资源。
条件符合时，QWaitCondition允许唤醒线程。例如，多个线程中某个线程被阻塞时，通过QWaitCondition提供的函数wakeOne()和wakeAll()可以唤醒该线程。
可重入性与线程安全
可重入性：两个以上线程并行访问时，即使不按照调用顺序重叠运行代码，也必须保证结果；
线程安全：线程并行运行的情况下，虽然保证可以使程序正常运行，但访问静态空间或共享（堆等内存对象）对象时，要使用互斥体等机制保证结果。
一个线程安全的函数不一定是可重入的；一个可重入的函数缺也不一定是线程安全的！

可重入函数主要用于多任务环境中，一个可重入的函数简单来说就是可以被中断的函数，也就是说，可以在这个函数执行的任何时刻中断它，转入OS调度下去执行另外一段代码，而返回控制时不会出现什么错误；而不可重入的函数由于使用了一些系统资源，比如全局变量区，中断向量表等，所以它如果被中断的话，可能会出现问题，这类函数是不能运行在多任务环境下的。

编写可重入函数时，若使用全局变量，则应通过关中断、信号量（即P、V操作）等手段对其加以保护。若对所使用的全局变量不加以保护，则此函数就不具有可重入性，即当多个线程调用此函数时，很有可能使有关全局变量变为不可知状态。

满足下列条件的函数多数是不可重入的：

函数体内使用了静态的数据结构和全局变量，若必须访问全局变量，利用互斥信号量来保护全局变量；；
函数体内调用了malloc()或者free()函数；
函数体内调用了标准I/O函数。
常见的不可重入函数有：

printf --------引用全局变量stdout
malloc --------全局内存分配表
free --------全局内存分配表
也就是说：本质上，可重入性与C++类或者没有全局静态变量的函数相似，由于只能访问自身所有的数据变量区域，所以即使有两个以上线程访问，也可以保证安全性。

QThread和QObjects
QThread类继承自QObjects类。因此，线程开始或结束时，QThread类发生发送信号事件。信号与槽的功能是QThread类从QObject类继承的，可以通过信号与槽处理开始或结束等操作，所以可以实现多线程。QObject是基于QTimer、QTcpSocket、QUdpSocket和QProcess之类的非图形用户界面的子类。

基于非图形用户界面的子类可以无线程操作。单一类运行某功能时，可以不需要线程。但是，运行单一类的目标程序的上级功能时，则必须通过线程实现。

线程A和线程B没有结束的情况下，应设计使主线程时间循环不结束；而若线程A迟迟不结束而导致主线程循环也迟迟不能结束，故也要防止线程A没有在一定时间内结束。

处理QThread的信号和槽的类型
Qt提供了可以决定信号与槽类型的枚举类，以在线程环境中适当处理事物。

决定信号与槽类型的枚举类
常量 值 说明
Qt::AutoConnection 0 如果其他线程中发生信号，则会插入队列，像QueuedConnection一样，否则如DirectConnection一样，直接连接到槽。发送信号时决定Connection类型。
Qt::DirectConnection 1 发生信号事件后，槽立即响应
Qt::QueuedConnection 2 返回收到的线程事件循环时，发生槽事件。槽在收到的线程中运行
Qt::BlockingQueuedConnection 3 与QueuedConnection一样，返回槽时，线程被阻塞。建立在事件发生处使用该类型
使用QtConcurrent类的并行编程
QtConcurrent类提供多线程功能，不使用互斥体、读写锁、等待条件和信号量等低级线程。使用QtConcurrent创建的程序会根据进程数自行调整使用的线程数。

---

 QThread类

简述
QThread类提供了与系统无关的线程。

QThread代表在程序中一个单独的线程控制。线程在run()中开始执行，默认情况下，run()通过调用exec()启动事件循环并在线程里运行一个Qt的事件循环。

详细描述
QThread类可以不受平台影响而实现线程。QThread提供在程序中可以控制和管理线程的多种成员函数和信号/槽。通过QThread类的成员函数start()启动线程。

QThread通过信号函数started()和finished()通知开始和结束，并查看线程状态；可以使用isFinished()和isRunning()来查询线程的状态；使用函数exit()和quit()可以结束线程。

如果使用多线程，有时需要等到所有线程终止。此时，使用函数wait()即可。线程中，使用成员函数sleep()、msleep()和usleep()可以暂停秒、毫秒及微秒单位的线程。

一般情况下，wait()和sleep()函数应该不需要，因为Qt是一个事件驱动型框架。考虑监听finished()信号来取代wait()，使用QTimer来取代sleep()。

静态函数currentThreadId()和currentThread()返回标识当前正在执行的线程。前者返回该线程平台特定的ID，后者返回一个线程指针。

要设置线程的名称，可以在启动线程之前调用setObjectName()。如果不调用setObjectName()，线程的名称将是线程对象的运行时类型（QThread子类的类名）。

线程管理
可以将常用的接口按照功能进行以下分类：

线程启动

void start(Priority priority = InheritPriority) [slot] 

调用后会执行run()函数，但在run()函数执行前会发射信号started()，操作系统将根据优先级参数调度线程。如果线程已经在运行，那么这个函数什么也不做。优先级参数的效果取决于操作系统的调度策略。特别是那些不支持线程优先级的系统优先级将会被忽略。

线程执行

int exec() [protected] 

进入事件循环并等待直到调用exit()，返回值是通过调用exit()来获得，如果调用成功则范围0。

void run() [virtual protected] 

线程的起点，在调用start()之后，新创建的线程就会调用这个函数，默认实现调用exec()，大多数需要重新实现这个函数，便于管理自己的线程。该方法返回时，该线程的执行将结束。

线程退出

void quit() [slot] 

告诉线程事件循环退出，返回0表示成功，相当于调用了QThread::exit(0)。

void exit(int returnCode = 0) 

告诉线程事件循环退出。 调用这个函数后，线程离开事件循环后返回，QEventLoop::exec()返回returnCode，按照惯例，0表示成功；任何非0值表示失败。

void terminate() [slot] 

终止线程，线程可能会立即被终止也可能不会，这取决于操作系统的调度策略，使用terminate()之后再使用QThread::wait()，以确保万无一失。当线程被终止后，所有等待中的线程将会被唤醒。

警告：此函数比较危险，不鼓励使用。线程可以在代码执行的任何点被终止。线程可能在更新数据时被终止，从而没有机会来清理自己，解锁等等。。。总之，只有在绝对必要时使用此函数。

void requestInterruption() 

请求线程的中断。该请求是咨询意见并且取决于线程上运行的代码，来决定是否及如何执行这样的请求。此函数不停止线程上运行的任何事件循环，并且在任何情况下都不会终止它。

线程等待

1 void msleep(unsigned long msecs) [static]     //强制当前线程睡眠msecs毫秒
2  
3 void sleep(unsigned long secs) [static]     //强制当前线程睡眠secs秒
4  
5 void usleep(unsigned long usecs) [static]     //强制当前线程睡眠usecs微秒
6  
7 bool wait(unsigned long time = ULONG_MAX)     //线程将会被阻塞，等待time毫秒。和sleep不同的是，如果线程退出，wait会返回。

线程状态

1 bool isFinished() const     //线程是否结束
2  
3 bool isRunning() const     //线程是否正在运行
4  
5 bool isInterruptionRequested() const     //如果线程上的任务运行应该停止，返回true。可以使用requestInterruption()请求中断。 
6  
7 //此函数可用于使长时间运行的任务干净地中断。从不检查或作用于该函数返回值是安全的，但是建议在长时间运行的函数中经常这样做。注意：不要过于频繁调用，以保持较低的开销。

线程优先级

void setPriority(Priority priority) 

设置正在运行线程的优先级。如果线程没有运行，此函数不执行任何操作并立即返回。使用的start()来启动一个线程具有特定的优先级。优先级参数可以是QThread::Priority枚举除InheritPriortyd的任何值。

Qt多线程优先级
常量 值 优先级
QThread::IdlePriority 0 没有其它线程运行时才调度
QThread::LowestPriority 1 比LowPriority调度频率低
QThread::LowPriority 2 比NormalPriority调度频率低
QThread::NormalPriority 3 操作系统的默认优先级
QThread::HighPriority 4 比NormalPriority调度频繁
QThread::HighestPriority 5 比HighPriority调度频繁
QThread::TimeCriticalPriority 6 尽可能频繁的调度
QThread::InheritPriority 7 使用和创建线程同样的优先级. 这是默认值

QThread类使用方式
QThread的使用方法有如下两种：

QObject::moveToThread()
继承QThread类
QObject::moveToThread
方法描述：

定义一个继承于QObject的worker类，在worker类中定义一个槽slot函数doWork()，这个函数中定义线程需要做的工作；
在要使用线程的controller类中，新建一个QThread的对象和woker类对象，使用moveToThread()方法将worker对象的事件循环全部交由QThread对象处理；
建立相关的信号函数和槽函数进行连接，然后发出信号触发QThread的槽函数，使其执行工作。
例子：

 1 #ifndef WORKER_H
 2 #define WORKER_H
 3 #include <QObject>
 4 #include<QDebug>
 5 #include<QThread>
 6 class Worker:public QObject                    //work定义了线程要执行的工作
 7 {
 8     Q_OBJECT
 9 public:
10     Worker(QObject* parent = nullptr){}
11 public slots:
12     void doWork(int parameter)                        //doWork定义了线程要执行的操作
13     {
14         qDebug()<<"receive the execute signal---------------------------------";
15         qDebug()<<"     current thread ID:"<<QThread::currentThreadId();
16        for(int i = 0;i!=1000000;++i)
17        {
18         ++parameter;
19        }
20        qDebug()<<"      finish the work and sent the resultReady signal\n";
21        emit resultReady(parameter);           //emit啥事也不干，是给程序员看的，表示发出信号发出信号
22     }
23  
24 signals:
25     void resultReady(const int result);               //线程完成工作时发送的信号
26 };
27  
28 #endif // WORKER_H

 1 #ifndef CONTROLLER_H
 2 #define CONTROLLER_H
 3 #include <QObject>
 4 #include<QThread>
 5 #include<QDebug>
 6 class Controller : public QObject            //controller用于启动线程和处理线程执行结果
 7 {
 8     Q_OBJECT
 9     QThread workerThread;
10 public:
11     Controller(QObject *parent= nullptr);
12     ~Controller();
13 public slots:
14     void handleResults(const int rslt)                        //处理线程执行的结果
15     {
16         qDebug()<<"receive the resultReady signal---------------------------------";
17         qDebug()<<"     current thread ID:"<<QThread::currentThreadId()<<'\n';
18         qDebug()<<"     the last result is:"<<rslt;
19     }
20 signals:
21     void operate(const int);                        //发送信号触发线程
22 };
23  
24 #endif // CONTROLLER_H

 1 #include "controller.h"
 2 #include <worker.h>
 3 Controller::Controller(QObject *parent) : QObject(parent)
 4 {
 5     Worker *worker = new Worker;
 6     worker->moveToThread(&workerThread);            //调用moveToThread将该任务交给workThread
 7  
 8     connect(this, SIGNAL(operate(const int)), worker, SLOT(doWork(int)));            //operate信号发射后启动线程工作
 9     connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);            //该线程结束时销毁
10     connect(worker, SIGNAL(resultReady(int)), this, SLOT(handleResults(int)));            //线程结束后发送信号，对结果进行处理
11  
12     workerThread.start();                //启动线程
13     qDebug()<<"emit the signal to execute!---------------------------------";
14     qDebug()<<"     current thread ID:"<<QThread::currentThreadId()<<'\n';
15     emit operate(0);
16 }
17  
18 Controller::~Controller()        //析构函数中调用quit()函数结束线程
19 {
20     workerThread.quit();
21     workerThread.wait();
22 }

继承QThread类

方法描述

• 自定义一个继承QThread的类MyThread，重载MyThread中的run()函数，在run()函数中写入需要执行的工作；
• 调用start()函数来启动线程。

例子：

 1 #ifndef MYTHREAD_H
 2 #define MYTHREAD_H
 3 #include<QThread>
 4 #include<QDebug>
 5 class MyThread : public QThread
 6 {
 7     Q_OBJECT
 8 public:
 9     MyThread(QObject* parent = nullptr);
10 signals:                //自定义发送的信号
11     void myThreadSignal(const int);
12 public slots:                //自定义槽
13     void myThreadSlot(const int);
14 protected:
15     void run() override;
16 };
17  
18 #endif // MYTHREAD_H

 1 #include "mythread.h"
 2  
 3 MyThread::MyThread(QObject *parent)
 4 {
 5  
 6 }
 7  
 8 void MyThread::run()
 9 {
10     qDebug()<<"myThread run() start to execute";
11     qDebug()<<"     current thread ID:"<<QThread::currentThreadId()<<'\n';
12     int count = 0;
13     for(int i = 0;i!=1000000;++i)
14     {
15      ++count;
16     }
17     emit myThreadSignal(count);
18     exec();
19 }
20  
21 void MyThread::myThreadSlot(const int val)
22 {
23     qDebug()<<"myThreadSlot() start to execute";
24     qDebug()<<"     current thread ID:"<<QThread::currentThreadId()<<'\n';
25     int count = 888;
26     for(int i = 0;i!=1000000;++i)
27     {
28      ++count;
29     }
30 }

 1 #include "controller.h"
 2 #include <mythread.h>
 3 Controller::Controller(QObject *parent) : QObject(parent)
 4 {
 5     myThrd = new MyThread;
 6     connect(myThrd,&MyThread::myThreadSignal,this,&Controller::handleResults);
 7     connect(myThrd, &QThread::finished, this, &QObject::deleteLater);            //该线程结束时销毁
 8     connect(this,&Controller::operate,myThrd,&MyThread::myThreadSlot);
 9  
10     myThrd->start();
11     QThread::sleep(5);
12     emit operate(999);
13 }
14  
15 Controller::~Controller()
16 {
17     myThrd->quit();
18     myThrd->wait();
19 }

两种方法的比较
两种方法来执行线程都可以，随便你的喜欢。不过看起来第二种更加简单，容易让人理解。不过我们的兴趣在于这两种使用方法到底有什么区别？其最大的区别在于：

moveToThread方法，是把我们需要的工作全部封装在一个类中，将每个任务定义为一个的槽函数，再建立触发这些槽的信号，然后把信号和槽连接起来，最后将这个类调用moveToThread方法交给一个QThread对象，再调用QThread的start()函数使其全权处理事件循环。于是，任何时候我们需要让线程执行某个任务，只需要发出对应的信号就可以。其优点是我们可以在一个worker类中定义很多个需要做的工作，然后发出触发的信号线程就可以执行。相比于子类化的QThread只能执行run()函数中的任务，moveToThread的方法中一个线程可以做很多不同的工作（只要发出任务的对应的信号即可）。
子类化QThread的方法，就是重写了QThread中的run()函数，在run()函数中定义了需要的工作。这样的结果是，我们自定义的子线程调用start()函数后，便开始执行run()函数。如果在自定义的线程类中定义相关槽函数，那么这些槽函数不会由子类化的QThread自身事件循环所执行，而是由该子线程的拥有者所在线程（一般都是主线程）来执行。如果你不明白的话，请看，第二个例子中，子类化的线程的槽函数中输出当前线程的ID，而这个ID居然是主线程的ID！！事实的确是如此，子类化的QThread只能执行run()函数中的任务直到run()函数退出，而它的槽函数根本不会被自己的线程执行。
QThread的信号与槽
启动或终止线程时，QThread提供了信号与槽。

QThread的信号
信号 含义
void finished() 终止线程实例运行，发送信号
void started() 启动线程实例，发送信号
void terminated() 结束线程实例，则发送信号
QThread的槽
槽 含义
void quit() 线程终止运行槽
void start(Priority) 线程启动槽
void terminate() 线程结束槽

 /*******************************************************

在Qt（C++）中使用QThread实现多线程

 

1. 引言

多线程对于需要处理耗时任务的应用很有用，一方面响应用户操作、更新界面显示，另一方面在“后台”进行耗时操作，比如大量运算、复制大文件、网络传输等。
使用Qt框架开发应用程序时，使用QThread类可以方便快捷地创建管理多线程。而多线程之间的通信也可使用Qt特有的“信号-槽”机制实现。
下面的说明以文件复制为例。主线程负责提供交互界面，显示复制进度等；子线程负责复制文件。最后附有可以执行的代码。

2. QThread使用方法1——重写run()函数

第一种使用方法是自己写一个类继承QThread，并重写其run()函数。
大家知道，C/C++程序都是从main()函数开始执行的。main()函数其实就是主进程的入口，main()函数退出了，则主进程退出，整个进程也就结束了。
而对于使用Qthread创建的进程而言，run()函数则是新线程的入口，run()函数退出，意味着线程的终止。复制文件的功能，就是在run()函数中执行的。
下面举个文件复制的例子。自定义一个类，继承自Qthread

CopyFileThread: public QThread
{
    Q_OBJECT
public:
    CopyFileThread(QObject * parent = 0);

protected:
    void run(); // 新线程入口
// 省略掉一些内容
}

在对应的cpp文件中，定义run()

void CopyFileThread::run()
{
    // 新线程入口
    // 初始化和操作放在这里
}

将这个类写好之后，在主线程的代码中生成一个CopyFileThread的实例，例如在mainwindow.cpp中写：

// mainwindow.h中
CopyFileThread * m_cpyThread;

// mainwindow.cpp中
m_cpyThread = new CopyFileThread;

在要开始复制的时候，比如按下“复制”按钮后，让这个线程开始执行：

m_cpyThread->start();

注意，使用start()函数来启动子线程，而不是run()。start()会自动调用run()。
线程开始执行后，就进入run()函数，执行复制文件的操作。而此时，主线程的显示和操作都不受影响。
如果需要进行对复制过程中可能发生的事件进行处理，例如界面显示复制进度、出错返回等等，应该从CopyFileThread中发出信号(signal），并事先连接到mainwindow的槽，由这些槽函数来处理事件。

3. QThread使用方法2——moveToThread()

如果不想每执行一种任务就自定义一个新线程，那么可以自定义用于完成任务的类，并让它们继承自QObject。例如，自定义一个FileCopier类，用于复制文件。

class FileCopier : public QObject
{
    Q_OBJECT
public:
    explicit FileCopier(QObject *parent = 0);

public slots:
    void startCopying();
    void cancelCopying();
}

注意这里我们定义了两个槽函数，分别用于复制的开始和取消。
这个类本身的实例化是在主线程中进行的，例如：

// mainwindow.h中
private:
    FileCopier* m_copier;

// mainwindow.cpp中，初始化时
    m_copier = new FileCopier;

此时m_copier还是属于主线程的。要将其移动到子线程处理，需要首先声明并实例化一个QThread：

// mainwindow.h中
signals:
    void startCopyRsquested();
private:
    QThread * m_childThread; // m_copier将被移动到此线程执行

// mainwindow.cpp中，初始化时
    m_childThread = new QThread; // 子线程，本身不负责复制

然后使用moveToThread()将m_copier移动到新线程。注意moveToThread()是QObject的公有函数，因此用于复制文件的类FileCopier必须继承自QObject。移动之后启动子线程。此时复制还没有开始。

    m_copier->moveToThread(m_childThread); // 将实例移动到新的线程，实现多线程运行
    m_childThread->start(); // 启动子线程

注意一定要记得启动子线程，否则线程没有运行，m_copier的功能也无法执行。
要开始复制，需要使用信号-槽机制，触发FileCopier的槽函数实现。因此要事先定义信号并连接：

// mainwindow.h中
signals:
    void startCopyRsquested();
// mainwindow.cpp中，初始化时
// 使用信号-槽机制，发出开始指令
    connect(this, SIGNAL(startCopyRsquested()), m_copier, SLOT(startCopying()));

当按下“复制”按钮后，发出信号。

    emit startCopyRsquested(); // 发送信号

m_copier在另一个线程接收到信号后，触发槽函数，开始复制文件。

4.常见问题

4.1. 子线程中能不能进行UI操作？

Qt中的UI操作，比如QMainWindow、QWidget之类的创建、操作，只能位于主线程！
这个限制意味着你不能在新的线程中使用QDialog、QMessageBox等。比如在新线程中复制文件出错，想弹出对话框警告？可以，但是必须将错误信息传到主线程，由主线程实现对话框警告。
因此一般思路是，主线程负责提供界面，子线程负责无UI的单一任务，通过“信号-槽”与主线程交互。

4.2. QThread中的哪些代码属于子线程？

QThread，以及继承QThread的类（以下统称QThread），他们的实例都属于新线程吗？答案是：不。
需要注意的是，QThread本身的实例是属于创建该实例的线程的。比如在主线程中创建一个QThread，那么这个QThread实例本身属于主线程。当然，QThread会开辟一个新线程（入口是run()），但是QThread本身并不属于这个新线程。也就是说，QThread本身的成员都不属于新线程，而且在QThread构造函数里通过new得到的实例，也不属于新线程。这一特性意味着，如果要实现多线程操作，那么你希望属于新线程的实例、变量等，应该在run()中进行初始化、实例化等操作。本文给出的例子就是这样操作的。
如果你的多线程程序运行起来，会出现关于thread的报警，思考一下，各种变量、实例是不是放对了位置，是不是真的位于新的线程里。

4.3. 怎么查看是不是真的实现了多线程？

可以打印出当前线程。对于所有继承自QObject的类，例如QMainwindow、QThread，以及自定义的各种类，可以调用QObject::thread()查看当前线程，这个函数返回的是一个QThread的指针。例如用qDebug()打印：
在mainwindow.cpp的某个函数里、QThread的run()函数里、自定义类的某个函数里，写上：

qDebug() << "Current thread:" << thread();

对比不同位置打印的指针，就可以知道它们是不是位于同一个线程了。

5.范例

范例实现了多线程复制文本文件。
提供的范例文件可用QtCreator编译运行。界面如下（不同的操作系统略有不同）：

范例中实现了本文介绍的两种方法，同时也给出了单线程复制对比。打钩选择不同的复制方法。可以发现，在使用多线程的时候，界面不会假死，第二根进度条的动画是持续的；而使用单线程复制的时候，“取消”按钮按不动，界面假死，而且第二根进度条的动画也停止了。
由于范例处理的文件很小，为了让复制过程持续较长时间以便使得现象明显，复制文件的时候，每复制一行加入了等待。

/*********************************************************************************** 

QThread详解

回顾Qt之线程（QThread），里面讲解了如何使用线程，但还有很多人留言没有看明白，那么今天我们来一起瞅瞅关于QThread管理线程的那些事儿。。。

一、线程管理

1、线程启动

void start(Priority priority = InheritPriority)

调用后会执行run()函数，但在run()函数执行前会发射信号started()，操作系统将根据优先级参数调度线程。如果线程已经在运行，那么这个函数什么也不做。优先级参数的效果取决于操作系统的调度策略。特别是那些不支持线程优先级的系统优先级将会被忽略（例如在Linux中，更多细节请参考sched_setscheduler(2) - Linux man page）。

2、线程执行

int exec()

进入事件循环并等待直到调用exit()，返回值是通过调用exit()来获得，如果调用成功则范围0。

virtual void run();

线程的起点，在调用start()之后，新创建的线程就会调用这个函数，默认实现调用exec()，大多数需要重新实现这个功能，便于管理自己的线程。该方法返回时，该线程的执行将结束。

3、线程退出

void quit()

告诉线程事件循环退出，返回0表示成功，相当于调用了QThread::exit(0)。

void exit(int returnCode = 0)

告诉线程事件循环退出。

调用这个函数后，线程离开事件循环后返回，QEventLoop::exec()返回returnCode，

按照惯例0表示成功，任何非0值表示失败。

void terminate()

终止线程，线程可能会立即被终止也可能不会，这取决于操作系统的调度策略，使用terminate()之后再使用QThread::wait()确保万无一失。

当线程被终止后，所有等待中的线程将会被唤醒。

警告：此功能比较危险，不鼓励使用。线程可以在代码执行的任何点被终止。线程可能在更新数据时被终止，从而没有机会来清理自己，解锁等等。。。总之，只有在绝对必要时使用此功能。

建议：一般情况下，都在run函数里面设置一个标识符，可以控制循环停止。然后才调用quit函数，退出线程。

4、线程等待

void msleep(unsigned long msecs)

强制当前线程睡眠msecs毫秒

void sleep(unsigned long secs)

强制当前线程睡眠secs秒

void usleep(unsigned long usecs)

强制当前线程睡眠usecs微秒

bool wait(unsigned long time = ULONG_MAX);

线程将会被阻塞，等待time毫秒。和sleep不同的是，如果线程退出，wait会返回。

5、线程状态

    bool isFinished() const    

    线程是否结束

    bool isRunning() const    

    线程是否正在运行

6、线程优先级

    void setPriority(Priority priority)

    这个函数设置正在运行线程的优先级。如果线程没有运行，此功能不执行任何操作并立即返回。使用的start()来启动一个线程具有特定的优先级。

    优先级参数可以是QThread::Priority枚举除InheritPriortyd的任何值。

    Priority priority() const

    下面来看下优先级中的各个枚举值：

Constant	Value	Description
QThread::IdlePriority	0	没有其它线程运行时才调度.
QThread::LowestPriority	1	比LowPriority调度频率低.
QThread::LowPriority	2	比NormalPriority调度频率低.
QThread::NormalPriority	3	操作系统默认的默认优先级.
QThread::HighPriority	4	比NormalPriority调度频繁.
QThread::HighestPriority	5	比HighPriority调度频繁.
QThread::TimeCriticalPriority	6	尽可能频繁的调度.
QThread::InheritPriority	7	使用和创建线程同样的优先级. 这是默认值.

 

二、主线程、次线程

在Qt之线程（QThread）一节中我介绍了QThread 的两种使用方法：

1、子类化 QThread（不使用事件循环）。

这是官方手册、例子以及相关书籍中都介绍的一种常用的方法。

a. 子类化 QThread

b. 重载 run 函数，run函数内有一个while或for的死循环（模拟耗时操作）

c. 设置一个标记为来控制死循环的退出。

2、子类化 QObject

a. 子类化 QObject

b. 定义槽函数

c. 将该子类的对象moveToThread到新线程中

run 对于线程的作用相当于main函数对于应用程序。它是线程的入口，run的开始和结束意味着线程的开始和结束。

采用这两种做法，毫无疑问都会在次线程中运行（这里说的是，run中的逻辑以及子类化QObject后连接通过moveToThread然后连接到QThread的started()信号的槽函数，这个下面会详细讲解）。

那么，线程中的槽函数是怎么运行的呢？

说到信号与槽，大家应该再熟悉不过了，包括我，特别喜欢使用自定义信号与槽，感觉用起来特方便、特棒。。。

经常使用，你能否100%的使用正确？你了解它的高级用法吗？

1、你是否在多次connect，还发现不了为什么槽函数会执行那N多次。

2、你是否了解disconnect

3、你是否了解connect中的第五个参数 Qt::ConnectionType

关于connect、disconnect信号、槽的使用可参考：Qt之信号与槽。既然谈到线程这里需要重点说下Qt::ConnectionType（信号与槽的传递方式）

Constant	Value	Description
Qt::AutoConnection	0	自动连接：（默认值）如果信号在接收者所依附的线程内发射，则等同于直接连接。如果发射信号的线程和接受者所依附的线程不同，则等同于队列连接。
Qt::DirectConnection	1	直接连接：当信号发射时，槽函数将直接被调用。无论槽函数所属对象在哪个线程，槽函数都在发射信号的线程内执行。
Qt::QueuedConnection	2	队列连接：当控制权回到接受者所依附线程的事件循环时，槽函数被调用。槽函数在接收者所依附线程执行。也就是说：这种方式既可以在线程内传递消息，也可以跨线程传递消息
Qt::BlockingQueuedConnection	3	与Qt::QueuedConnection类似，但是会阻塞等到关联的slot都被执行。这里出现了阻塞这个词，说明它是专门用来多线程间传递消息的。

举例：

MyObject.h

#ifndef MYOBJECT_H
#define MYOBJECT_H

#include 

class MyObject : public QObject
{
    Q_OBJECT

public:
    explicit MyObject(QObject *parent = 0);

public slots:
    void start();
};

#endif // MYOBJECT_H

MyObject.cpp

#include "MyObject.h"
#include 
#include 

MyObject::MyObject(QObject *parent)
    : QObject(parent)
{

}

void MyObject::start()
{
    qDebug() << QString("my object thread id:") << QThread::currentThreadId();
}

main.cpp

#include "MyObject.h"
#include 
#include 
#include 

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    qDebug() << QString("main thread id:") << QThread::currentThreadId();

    MyObject object;
    QThread thread;
    object.moveToThread(&thread);
    QObject::connect(&thread, SIGNAL(started()), &object, SLOT(start()));
    thread.start();

    return a.exec();
} 

查看运行结果：

  "main thread id:" 0xf08

  "my object thread id:" 0x216c

    显然主线程与槽函数的线程是不同的（你可以多次尝试，屡试不爽。。。），因为moveToThread后MyObject所在的线程为QThread，继上面介绍的thread.start()执行后首先会发射started()信号，也就是说started()信号发射是在次线程中进行的，所以无论采取Qt::AutoConnection、Qt::DirectConnection、Qt::QueuedConnection哪种连接方式，主线程与槽函数的线程都是不同的。

1、修改代码如下：

    MyObject object;
    QThread thread;
    //object.moveToThread(&thread);
    QObject::connect(&thread, SIGNAL(started()), &object, SLOT(start()), Qt::DirectConnection);
    thread.start();

查看运行结果：

  "main thread id:" 0x2688

  "my object thread id:" 0x2110 

    显然主线程与槽函数的线程是不同的，MyObject所依附的线程为主线程（因为注释掉了moveToThread），继上面介绍的Qt::DirectConnection（无论槽函数所属对象在哪个线程，槽函数都在发射信号的线程内执行）。也就是说started()信号发射是在次线程中进行的，槽函数也是在次线程中进行的，所以主线程与槽函数的线程是不同的。

2、修改代码如下：

    MyObject object;
    QThread thread;
    //object.moveToThread(&thread);
    QObject::connect(&thread, SIGNAL(started()), &object, SLOT(start()), Qt::QueuedConnection);
    thread.start();

查看运行结果：

  "main thread id:" 0x24ec

  "my object thread id:" 0x24ec 

    显然主线程与槽函数的线程是相同的，继上面介绍的Qt::QueuedConnection（槽函数在接收者所依附线程执行）。也就是说started()信号发射是在次线程中进行的，但MyObject所依附的线程为主线程（因为注释掉了moveToThread），所以主线程与槽函数的线程必然是相同的。

3、修改代码如下：

    MyObject object;
    QThread thread;
    //object.moveToThread(&thread);
    QObject::connect(&thread, SIGNAL(started()), &object, SLOT(start()), Qt::AutoConnection);
    thread.start();

查看运行结果：

  "main thread id:" 0x2700

  "my object thread id:" 0x2700 

    显然主线程与槽函数的线程是相同的，MyObject所依附的线程为主线程（因为注释掉了moveToThread），继上面介绍的Qt::AutoConnection（如果信号在接收者所依附的线程内发射，则等同于直接连接。如果发射信号的线程和接受者所依附的线程不同，则等同于队列连接。）。因为started()信号和MyObject依附的线程不同，所以结果和Qt::QueuedConnection对应的相同，所以主线程与槽函数的线程是相同的。

    基本就介绍到这里，QThread使用和上面的大同小异，run里面执行的代码都是在次线程中，如果是QThead的槽函数，那么结论同上！