事先宣告：此篇部落格非完全原創

一. 同步
synchronous.h

#ifndef SYNC_H
#define SYNC_H

#include <QObject>
#include <QDebug>

class MyTestA : public QObject
{
    Q_OBJECT
public:
    void emitSignal()
    {
        signalMyTestA();
    }

public slots:
    void slotMyTestA()
    {
        qDebug()<<"slotMyTestA is called."
 
;
    }
signals:
    void signalMyTestA();
};


class MyTestB : public QObject
{
    Q_OBJECT
public slots:
    void slotMyTestB()
    {
        qDebug()<<"slotMyTestB is called.";
    }
signals:
    void signalMyTestB();
};


#endif // SYNC_H

main.cpp

#include <QApplication>

#include "synchronous.h"
 

#include "asynchronous.h"

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

    MyTestA a;
    MyTestB b;      
    QObject::connect(&a,SIGNAL(signalMyTestA()),&b,SLOT(slotMyTestB()));//a和b都在主執行緒中-->
//    a.emitSignal();// <--並且發訊號也在主執行緒中，同步呼叫

    return app.exec();
}
 

二. 非同步
場景一：
asynchronous.h

#當sender和receiver在同一執行緒時，就是同步模式，而在不同執行緒時，則是非同步模式，其實這是錯誤的觀念。

class MyTestA : public QObject
{
    Q_OBJECT
public:
    void emitSignal()
    {
        signalMyTestA();
    }

public slots:
    void slotMyTestA()
    {
        qDebug()<<"slotMyTestA is called.";
    }
signals:
    void signalMyTestA();
};


class MyTestB : public QObject
{
    Q_OBJECT
public slots:
    void slotMyTestB()
    {
        qDebug()<<"slotMyTestB is called.";
    }
signals:
    void signalMyTestB();
};


extern MyTestB *g_pMyTestB;
class MyTestC : public QThread
{
    Q_OBJECT
public:

    void run()
    {
        MyTestA a;
        connect(&a,SIGNAL(signalMyTestA()),g_pMyTestB,SLOT(slotMyTestB()));//a在子執行緒中，b在主執行緒中-->
        a.emitSignal();// <--發訊號在子執行緒中，非同步呼叫
        exec();

    }

public slots:
    void slotMyTestC()
    {
        qDebug()<<"slotMyTestC is called.";
    }
signals:
    void signalMyTestC();

};

main.cpp

#include <QApplication>

#include "synchronous.h"
#include "asynchronous.h"

MyTestB *g_pMyTestB = NULL;

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    MyTestB b;
    g_pMyTestB = &b;
    MyTestC c;
    c.start();

    return app.exec();
}

場景二：
asynchronous.h

//在Auto模式下，如果sender的觸發時所處的執行緒和receiver不同，也會是非同步呼叫。

class MyTestA : public QObject
{
    Q_OBJECT
public:
    void emitSignal()
    {
        signalMyTestA();
    }

public slots:
    void slotMyTestA()
    {
        qDebug()<<"slotMyTestA is called.";
    }
signals:
    void signalMyTestA();
};

class MyTestB : public QObject
{
    Q_OBJECT
public slots:
    void slotMyTestB()
    {
        qDebug()<<"slotMyTestB is called.";
    }
signals:
    void signalMyTestB();
};

extern MyTestB *g_pMyTestB;
extern MyTestA *g_pMyTestA;
class MyTestC : public QThread
{
    Q_OBJECT
public:

    void run()
    {
        g_pMyTestA->emitSignal();//<--但是發訊號在子執行緒中，非同步呼叫
        exec();
    }

public slots:
    void slotMyTestC()
    {
        qDebug()<<"slotMyTestC is called.";
    }
signals:
    void signalMyTestC();
};

main.cpp

#include <QApplication>

#include "synchronous.h"
#include "asynchronous.h"

MyTestB *g_pMyTestB = NULL;
MyTestA *g_pMyTestA = NULL;
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    MyTestA a;
    g_pMyTestA = &a;
    MyTestB b;
    g_pMyTestB = &b;
    QObject::connect(&a,SIGNAL(signalMyTestA()),&b,SLOT(slotMyTestB()));//a和b都在主執行緒中-->
    MyTestC c;
    c.start();

    return app.exec();
}

最終得出的結論：只有當訊號的傳送者和接收者處於同一個執行緒，並且傳送者觸發訊號時和接收者處於同一個執行緒，才會是同步呼叫。

determine if this connection should be sent immediately or put into
the event queue
if ((c->connectionType == Qt::AutoConnection
&& (currentThreadData != sender->d_func()->threadData
|| receiver->d_func()->threadData != sender->d_func()->threadData))
|| (c->connectionType == Qt::QueuedConnection)) {
queued_activate(sender, signal_absolute_index, c, argv ? argv : empty_argv);
continue;
} else if (c->connectionType == Qt::BlockingQueuedConnection) {
blocking_activate(sender, signal_absolute_index, c, argv ? argv : empty_argv);
continue;
}

摘自qobject.cpp