关于Qt使用moveToThread建立多线程信号与槽不触发的问题

• Qt建立多线程的方法一般有两种

1. 新建一个类MyThread，继承QThread类，重写run()函数，通过调用start()函数启动线程。
2. 新建一个类MyThread，继承QObject类，新建类不可指定父对象！新建一个QThread的变量thread，新类的实例对象使用moveToThread(&thread)将自己移动到新线程去，调用start()函数启动线程，但此时子线程虽然启动了，但任务函数未启动，所以需要使用connect函数将start()信号与任务函数连接。

案例如下：

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QObject>
#include <QThread>
#include <QMutex>
#include <QWaitCondition>
#include <QMutexLocker>
#include <QDebug>

class MyThread : public QObject
{
    Q_OBJECT
public:
    explicit MyThread(QObject *parent = nullptr);

    void work();
    void pause();
    void resume();

private:
    bool paused;
    QMutex mtx;
    QWaitCondition condition;

signals:
    void sendNum(int num);

};

#endif // MYTHREAD_H

#include "mythread.h"

MyThread::MyThread(QObject *parent)
    : QObject{parent}
{
    paused = false;
}

void MyThread::work()
{
    int num = 0;
    while(num<1000){
        mtx.lock();
        if(paused)
        {
            condition.wait(&mtx);
        }
        mtx.unlock();
        emit sendNum(num);
        QThread::msleep(500);
        num++;
        // exec();
    }
}

void MyThread::pause()
{
    qDebug()<<"接收休眠信号";
    qDebug()<<"线程ID："<<QThread::currentThreadId();
    QMutexLocker<QMutex> locker(&mtx);
    paused = true;
}

void MyThread::resume()
{
    qDebug()<<"接收唤醒信号";
    qDebug()<<"线程ID："<<QThread::currentThreadId();
    {
        QMutexLocker<QMutex> locker(&mtx);
        paused = false;
    }
    condition.notify_one();
}

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QThread>
#include <QDebug>
#include <QEventLoop>

#include "mythread.h"

QT_BEGIN_NAMESPACE
namespace Ui {
class Widget;
}
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

private:
    Ui::Widget *ui;

    QThread *thread;
    MyThread *mythread;

    bool isRun;
    bool paused;

signals:
    void sendSleep();
    void sendWake();

private slots:
    void on_lauch_clicked();
    void on_pause_clicked();
};
#endif // WIDGET_H

#include "widget.h"
#include "ui_widget.h"

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);

    paused = false;
    isRun = false;

    thread = new QThread();
    mythread = new MyThread();

    mythread->moveToThread(thread);

    connect(thread,&QThread::started,mythread,&MyThread::work);
    connect(mythread,&MyThread::sendNum,this,[&](int num){
        ui->lcdNumber->display(num);
    });

    // connect(this,&Widget::sendSleep,mythread,&MyThread::pause);
    // connect(this,&Widget::sendWake,mythread,&MyThread::resume);

    connect(this,&Widget::sendSleep,this,[&](){
        mythread->pause();
        qDebug()<<QThread::currentThreadId();
    });
    connect(this,&Widget::sendWake,this,[&](){
        mythread->resume();
        qDebug()<<QThread::currentThreadId();
    });

    qDebug()<<thread->isRunning();
}

Widget::~Widget()
{
    thread->deleteLater();
    delete mythread;
    delete ui;
}

void Widget::on_lauch_clicked()
{
    if(thread->isRunning()&&paused == false){
        qDebug()<<"什么也不做";
        return;
    }
    else if(thread->isRunning() == false){
        qDebug()<<"线程启动";
        thread->start();
    }
    else if(thread->isRunning()&&paused){
        qDebug()<<"发射唤醒信号";
        emit sendWake();
        // exec();
        // QEventLoop::exec();
        paused = false;
    }
    qDebug()<<thread->isRunning();
}


void Widget::on_pause_clicked()
{
    if(thread->isRunning()&&paused == false)
    {
        qDebug()<<"发射休眠信号";
        emit sendSleep();
        paused = true;
    }
}

一开始按照使用槽函数的形式传递信号，程序运行之后可以正常启动，但是按下暂停按钮后子线程不暂停。查找了诸多资料，发现跟事件循环机制有关。

原因：Qobject对象是有线程归属的，或者说其存活在特定线程中。当接收到队列连接的信或 投递的事件，槽函数或事件处理在其归属线程中执行。 如果一个对象没有归属线程（也就是thread()接口调用返回值为空），或者其所属线程没有运行中的消息循环，队列连接的信号或投递的事件是无法正常接收的。

原文链接：Qt跨线程信号槽槽函数无响应（未调用）问题

• connect的第五个参数为连接方式

Qt::AutoConnection                    默认连接
Qt::DirectConnection                  槽函数立即调用
Qt::BlockingQueuedConnection          同步调用
Qt::QueuedConnection                  异步调用
Qt::UniqueConnection                  单一连接

(1) Qt::DirectConnection(立即调用)

直接在发送信号的线程中调用槽函数(无论发送信号和槽函数是否位于同一线程)，等价于槽函数的实时调用。

也就是说槽函数在发送信号所在线程调用。直接连接，其实就等同于直接调用。

 

(2) Qt::QueuedConnection(异步调用)

信号发送至目标线程的事件队列(发送信号和槽函数位于不同线程)，交由目标线程处理，当前线程继续向下执行。

当信号发送时候，槽函数不会直接调用，直到接受者线程取得控制权时进行事件处理循环时候，槽函数才会调用执行。

跨线程时只有队列连接是安全的，队列连接借助的是事件系统，所以你可以通过postEvent在线程间传递数据。

 

(3) Qt::BlockingQueuedConnection(同步调用)

信号发送至目标线程的事件队列，由目标线程处理。当前线程阻塞等待槽函数的返回，之后向下执行。

Qt::BlockingQueuedConnection 和QueuedConnectionx相同，但是sender发送后线程会进入阻塞状态，

只有receiver线程执行槽函数完成，才会结束阻塞状态，所以这种参数类型设定情况下，sender和receiver不能在同一个线程，否则会造成死锁发生。

 

(4) Qt::AutoConnection(默认连接)

当发送信号线程=槽函数线程时，效果等价于Qt::DirectConnection；

当发送信号线程!=槽函数线程时，效果等价于Qt::QueuedConnection。

Qt::AutoConnection是connect()函数第5个参数的默认值，也是实际开发中字常用的连接方式。

 

(5) Qt::UniqueConnection(单一连接)

功能和AutoConnection相同，同样能自动确定连接类型，但是加了限制：同一个信号和同一个槽函数之间只能有一个连接。

 

这也就解释为什么子线程没有响应信号的原因了，使用moveToThread建立的线程，默认没有开启事件循环机制，所以子线程无法处理信号。使用继承QThread类重写run函数的方式建立的线程，在4.4版本及以后默认开启事件循环机制（之前版本可以使用exec()函数开启）。

 

解决办法：

1. 开启事件循环机制------目前不知如何使用代码开启事件循环机制，有的博主贴上去的代码，线程类同时继承QObject和QThread类，通过QThread类的exec()函数开启事件循环机制，实测由于多继承的问题会报错。。。
2. connect连接方式改为直接连接，相当于在主线程中调用子线程的函数。
3. 可以将connect中的槽函数在Lambda表达式中调用，跟方法二同理都是在主线程中调用子线程的函数。