QT中的线程与事件循环理解（2）

1. Qt多线程与Qobject的关系

　　每一个 Qt 应用程序至少有一个事件循环，就是调用了QCoreApplication::exec()的那个事件循环。不过，QThread也可以开启事件循环。只不过这是一个受限于线程内部的事件循环。因此我们将处于调用main()函数的那个线程，并且由QCoreApplication::exec()创建开启的那个事件循环成为主事件循环，或者直接叫主循环。注意，QCoreApplication::exec()只能在调用main()函数的线程调用。主循环所在的线程就是主线程，也被成为 GUI 线程，因为所有有关 GUI 的操作都必须在这个线程进行。QThread的局部事件循环则可以通过在QThread::run()中调用QThread::exec()开启：

class Thread : public QThread
{
protected:
    void run() {
        
    }
};

　　注意：Qt 4.4 版本以后，QThread::run()不再是纯虚函数，它会调用QThread::exec()函数。与QCoreApplication一样，QThread也有QThread::quit()和QThread::exit()函数来终止事件循环。

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.

　　线程的事件循环用于为线程中的所有QObjects对象分发事件；默认情况下，这些对象包括线程中创建的所有对象，或者是在别处创建完成后被移动到该线程的对象（我们会在后面详细介绍“移动”这个问题）。我们说，一个QObject的所依附的线程（thread affinity）是指它所在的那个线程。它同样适用于在QThread的构造函数中构建的对象：

class MyThread : public QThread
{
public:
    MyThread()
    {
        otherObj = new QObject;
    }    
 
private:
    QObject obj;
    QObject *otherObj;
    QScopedPointer yetAnotherObj;
};

　　上面线程对象中的子成员：obj， 以及otherObj所指向的对象，以及yetAnotherObj，都在使创建Mytherad的线程，即主线程，而不是子线程。

　　在我们创建了MyThread对象之后，obj、otherObj和yetAnotherObj的线程依附性是怎样的？是不是就是MyThread所表示的那个线程？要回答这个问题，我们必须看看究竟是哪个线程创建了它们：实际上，是调用了MyThread构造函数的线程创建了它们。因此，这些对象不在MyThread所表示的线程，而是在创建了MyThread的那个线程中。　　

（1）QObject::connect

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

　　通过指定connect的连接方式，如果指定直接连接(Direct Connection)，则该槽函数将再信号发出的线程中直接执行，而不用判定当前信号发出的线程与槽函数所在线程的状态；如果指定队列连接(Queued Connection)，则该槽函数在接受者所依附的线程的线程循环中被指定调用；如果为自动连接(Auto Connection)需要判定发射信号的线程和接受者所依附的线程是否相同，进行细分指定。

• 自动连接(Auto Connection)
  • 这是默认设置
  • 如果发送者的信号（不是发送者对象）在接收者所依附的线程内发射，则等同于直接连接
  • 如果发射信号的线程和接受者所依附的线程不同，则等同于队列连接
  • 也就是这说，只存在下面两种情况
• 直接连接(Direct Connection)
  • 当信号发射时，槽函数将直接被调用。
  • 无论槽函数所属对象在哪个线程，槽函数都在发射信号的线程内执行。
• 队列连接(Queued Connection)
  • 当控制权回到接受者所依附线程的事件循环时，槽函数被调用。
  • 槽函数在接收者所依附线程执行。

（2）qT线程管理的原则：

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

【1】主线程(信号)QThread(槽)

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

　　因为connect采用默认的链接方式，则需要判定发射信号的线程和接受者所依附的线程是否相同，信号在主线程中发射 且槽函数所在的对象依附于线程， 因此链接方式是直接连接，从而运行结果是：槽函数的线程Id和主线程ID是一样的！

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

　　你会发现 QThread 中 slot 和 run 函数共同操作的对象，都会用QMutex锁住。因为此时run 是另一个线程，即子线程。而slot则是在主线程执行。必须适应锁来保证数据同步。

　　如果想让槽函数slot在次线程运行(比如它执行耗时的操作，会让主线程卡死)

• 将 thread 依附的线程改为次线程不就行了，这也是代码中注释掉的 moveToThread(this)所做的

　　去掉注释，你会发现slot在次线程中运行结果：

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

　　但这是 Bradley T. Hughes 强烈批判的用法。不推荐这样使用。

【2】run中信号与QThread中槽

　　即，信号在子线程发射，而槽函数谁线程的槽函数，而线程对象在主线程中创建，如果链接采用自动链接，则条件判断比为队列连接，且由主线程在主线程的事件循环中执行。如下所示：

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

　　如果指定为直接连接方式，则槽函数将在次线程(信号发出的线程)执行，这样，你需要处理slot和它的对象所在线程的同步。需要 QMutex 一类的东西。

推荐的方法

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

 
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(); 
}

　　执行结果：

main thread: 0x1a5c 
from thread slot: 0x186c

 　　确实简单，只需要再object的子类中新建“耗时功能”的实现“即可，然后将此对象moveToThread 到线程对象即可。

2. QT多线程原则

　　我们可以通过调用QObject::thread()可以查询一个QObject的线程依附性。

　　注意，在QCoreApplication对象之前创建的QObject没有所谓线程依附性，因此也就没有对象为其派发事件。也就是说，实际是QCoreApplication创建了代表主线程的QThread对象。

　　

　　我们可以使用线程安全的QCoreApplication::postEvent()函数向一个对象发送事件。它将把事件加入到对象所在的线程的事件队列中，因此，如果这个线程没有运行事件循环，即没有依附的线程，这个事件也不会被派发。但是可以通过将这种浮游对象通过QObject::moveToThread()来移入到一个已有的线程中，从而确保这些浮游的对象可以依附线程。

 　　值得注意的一点是，虽然QObject是可重入的，但是 GUI 类，特别是QWidget及其所有的子类，都是不是可重入的。它们只能在主线程使用。由于这些 GUI 类大都需要一个事件循环，所以，调用QCoreApplication::exec()也必须是主线程，否则这些 GUI 类就没有事件循环了。你不能有两个线程同时访问一个QObject对象，除非这个对象的内部数据都已经很好地序列化（例如为每个数据访问加锁）。记住，在你从另外的线程访问一个对象时，它可能正在处理所在线程的事件循环派发的事件！基于同样的原因，你也不能在另外的线程直接delete一个QObject对象，相反，你需要调用QObject::deleteLater()函数，这个函数会给对象所在线程发送一个删除的事件。

（1）QObject的线程依附性是可以改变的，方法是调用QObject::moveToThread()函数。该函数会改变一个对象及其所有子对象的线程依附性。由于QObject不是线程安全的，所以我们只能在该对象所在线程上调用这个函数。也就是说，我们只能在对象所在线程将这个对象移动到另外的线程，不能在另外的线程改变对象的线程依附性。

（2）Qt 要求QObject的所有子对象都必须和其父对象在同一线程。这意味着：

• 不能对有父对象（parent 属性）的对象使用QObject::moveToThread()函数
• 不能在QThread中以这个QThread本身作为父对象创建对象，，这是因为要创建该线程对象必然在其他的线程中创建，即该线程对象必然依附于其他线程对象，而以该线程对象为父类的子对向，在run函数中进行新建子类对象，若以其作为父对象，则与QT所定义的原则冲突，因此禁止。

class Thread : public QThread {
    void run() {
        QObject *obj = new QObject(this); // 错误！
    }
};

　　这是因为QThread对象所依附的线程是创建它的那个线程，而不是它所代表的线程。

 （3）Qt 还要求，在代表一个线程的QThread对象销毁之前，所有在这个线程中的对象都必须先delete。

　　要达到这一点并不困难：我们只需在QThread::run()的栈空间（直接定义对象）上创建对象即可。

　　 现在的问题是，既然线程创建的对象都只能在函数栈上，怎么能让这些对象与其它线程的对象通信呢？Qt 提供了一个优雅清晰的解决方案：我们在线程的事件队列中加入一个事件，然后在事件处理函数中调用我们所关心的函数。显然这需要线程有一个事件循环。这种机制依赖于 moc 提供的反射：因此，只有信号、槽和使用Q_INVOKABLE宏标记的函数可以在另外的线程中调用。

 　　QMetaObject::invokeMethod()静态函数会这样调用：

QMetaObject::invokeMethod(object, "methodName",
                          Qt::QueuedConnection,
                          Q_ARG(type1, arg1),
                          Q_ARG(type2, arg2));

　　上面函数调用中出现的参数类型都必须提供一个公有构造函数，一个公有的析构函数和一个公有的复制构造函数，并且要使用qRegisterMetaType()函数向 Qt 类型系统注册。

　　跨线程的信号槽也是类似的。当我们将信号与槽连接起来时，QObject::connect()的最后一个参数将指定连接类型：

• Qt::DirectConnection：直接连接意味着槽函数将在信号发出的线程直接调用
• Qt::QueuedConnection：队列连接意味着向接受者所在线程发送一个事件，该线程的事件循环将获得这个事件，然后之后的某个时刻调用槽函数
• Qt::BlockingQueuedConnection：阻塞的队列连接就像队列连接，但是发送者线程将会阻塞，直到接受者所在线程的事件循环获得这个事件，槽函数被调用之后，函数才会返回
• Qt::AutoConnection：自动连接（默认）意味着如果接受者所在线程就是当前线程，则使用直接连接；否则将使用队列连接；即如果接受者依附的线程就是当前线程，则直接连接，信号发出就调用。如果接受者依附的线程是其他线程，则队列连接，即向接受者所在线程发送一个事件，该线程的事件循环将获得这个事件，然后之后的某个时刻调用槽函数。

　　注意在上面每种情况中，发送者所在线程都是无关紧要的！在自动连接情况下，Qt 需要查看信号发出的线程是不是与接受者所在线程一致，来决定连接类型。注意，Qt 检查的是信号发出的线程，而不是信号发出的对象所在的线程！我们可以看看下面的代码：

class Thread : public QThread
{
Q_OBJECT
signals:
    void aSignal();
protected:
    void run() {
        emit aSignal();
    }
};
 
/* ... */
Thread thread;
Object obj;
QObject::connect(&thread, SIGNAL(aSignal()), &obj, SLOT(aSlot()));
thread.start();

　　aSignal()信号在一个新的线程被发出（也就是Thread所代表的线程）。注意，因为这个线程并不是Object所在的线程（Object所在的线程和Thread所在的是同一个线程），但是aSignal()确实在Thread所代表的新线程中发出，因此，必然是队列连接。

3. 多线程的数据交互，数据同步问题

　　线程对象依附的线程VS线程代表的新线程执行中对原有线程的访问问题

class Thread : public QThread
{
Q_OBJECT
slots:
    void aSlot() {
        /* ... */
    }
protected:
    void run() {
        /* ... */
    }
};
 
/* ... */
Thread thread;
Object obj;
QObject::connect(&obj, SIGNAL(aSignal()), &thread, SLOT(aSlot()));
thread.start();
obj.emitSignal();

　　这里的obj发出aSignal()信号时，使用哪种连接方式？答案是：直接连接。因为Thread对象所在线程发出了信号，也就是信号发出的线程与接受者是同一个。在aSlot()槽函数中，我们可以直接访问Thread的某些成员变量，但是注意，在我们访问这些成员变量时，Thread::run()函数可能也在访问！这意味着二者并发进行：这是一个完美的导致崩溃的隐藏bug

 　　　

class Thread : public QThread
{
Q_OBJECT
slots:
    void aSlot() {
        /* ... */
    }
protected:
    void run() {
        QObject *obj = new Object;
        connect(obj, SIGNAL(aSignal()), this, SLOT(aSlot()));
        /* ... */
    }
};

　　上面也是队列连接，且Thread的aSlot槽函数依附于Thread对象的依附线程，即主线程。因此与子线程中的信号不在同一个线程中。

　　如果为了在子线程中调用线程对象本身的槽函数，且槽函数的执行也在该子线程中。则采用

1. 在线程的构造函数中使用QObject::moveToThread()方法

2. 直接指定连接方式为 ：Driect连接方式

3. 采用上文中推荐的方法。

 第一种：在线程构造函数中，QThread对象不是线程本身，将改对象依附到其自己所创建的线程中。

　　实际上，这的确可行（因为Thread的线程依附性被改变了：它所在的线程成了自己），但是这并不是一个好主意。这种代码意味着我们其实误解了线程对象（QThread子类）的设计意图：它们其实是用于管理它所代表的线程的对象。因此，它们应该在另外的线程被使用（通常就是它自己所在的线程），而不是在自己所代表的线程中。

class Thread : public QThread {
Q_OBJECT
public:
    Thread() {
        moveToThread(this); // 错误！，不推荐
    }
 
    /* ... */
};

第二种：也不推荐

第三种：最好的解决方式，就是采用上面提到的，我们可以利用一个QObject的子类，使用QObject::moveToThread()改变其线程依附性：将处理任务的部分与管理线程的部分分离。

endl;