【Qt线程-4】事件循环嵌套,BlockingQueuedConnection与QWaitCondition比较

背景:

个人学习多线程控制,写了一些博文用于记录:

【Qt线程-1】this,volatile,exec(),moveToThread()

【Qt线程-2】事件循环(QCoreApplication::processEvents,exec)的应用

【Qt线程-3】使用事件循环,信号,stop变量,sleep阻塞,QWaitCondition+QMutex条件变量,退出子线程工作

【Qt线程-5】生产者&消费者模型应用(多态,子线程控制,协同,事件循环)

主要用于线程间通信,实现子线程控制。

这里我想特别说明,事件循环是非常重要的概念,可以不知道原理,但是它的作用一定要理解透彻!!!它与操作系统的调度时序有关,与信号槽和队列响应有关,与deletelater有关,与QThread::wait()有关。这是目前为止我遇到的和理解的。

偶然看到一位朋友的博客:

14.QueuedConnection和BlockingQueuedConnection连接方式源码分析_Master Cui的博客-CSDN博客_blockingqueuedconnection

他很了不起,写了很多有深度的文章。从这篇博客中,原本很常用的信号槽机制,我突然想研究一下阻塞队列连接方式的效果。亦即:Qt::BlockingQueuedConnection,connect函数的最后一个参数。

概念——信号槽连接方式:

qt信号槽的连接方式一共就这几种:

Qt::AutoConnection

Qt::DirectConnection

Qt::QueuedConnection

Qt::BlockingQueuedConnection

Qt::UniqueConnection

qt手册以及网络上的介绍太多太详细了。其实很简单,通常我不用这个参数,直接就是auto模式,qt会自动布置。

信号与槽在同一个线程时,默认是direct方式,也就是顺序执行的,发送信号以后立刻执行槽函数,然后执行发信号后面的语句。发信号就好像调用函数一样,执行完函数再执行后面的代码。

信号与槽不再同一个线程时,默认是队列模式,执行顺序受os调度影响,异步执行。发送信号以后不会立刻执行另一个线程的槽函数,而是把发送信号后面的语句一口气执行完,再执行另一个线程的槽。这里涉及事件循环的概念,不再赘述。

同样是信号与槽不再一个线程,还可以采用阻塞队列模式,就是同时具备上两种方式的特点。发送完信号,直接执行槽,然后执行发信号后面的代码。发信号这个线程会阻塞一下,等待槽执行完毕。

最后一种见名知意,不允许多次连接,如果不选这种模式,连接一次,就会触发一次槽。

原本上面这些连接方式不需要特别深入,知道即可。但是我对阻塞队列模式感兴趣,因为它特别像条件变量的效果,QWaitCondition。所以,先看一种场景,事件循环嵌套。

场景——事件循环嵌套:

先看一段简单的代码:

#include "obj.h"
#include 
#include 
#include 

Obj::Obj()
{

}

void Obj::f_Start()
{
    m_bStop = false;
    m_iLoopLevel++;

    while (true)
    {
        QCoreApplication::processEvents();//事件循环

        if (m_bStop)//退出判断
        {
            break;
        }

        QThread::msleep(200);//个人感觉,实际项目中少用sleep,用非阻塞方式友好一些
    }

    qDebug() << "Sub thread: event loop exists level: " << m_iLoopLevel;
    m_iLoopLevel--;

    if (m_iLoopLevel == 0)
    {
        f_Caller_Wakeup();
        qDebug() << "Sub thread: end.";
    }
}

void Obj::onStart()//这是一个槽函数,如果多次被触发,会让上面while循环中的eventloop嵌套
{
    f_Start();
}

void Obj::onStop()//用于接受停止命令,从而退出while循环,结束子线程
{
    qDebug() << "Sub thread: stopping...";
    m_bStop = true;
}

同时我做了一个窗体,用于人为控制子线程。

【Qt线程-4】事件循环嵌套,BlockingQueuedConnection与QWaitCondition比较_第1张图片

 点一次start就触发一层事件循环,点击stop会终止子线程所有循环。

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "obj.h"
#include 
#include 
#include 

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

    m_obj = new Obj;
    connect(this, SIGNAL(sigStart()), m_obj, SLOT(onStart()));
    connect(this, SIGNAL(sigStop()), m_obj, SLOT(onStop()));
    m_obj->setParent(nullptr);

    QThread *thd = new QThread;
    thd->start();

    m_obj->moveToThread(thd);
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::on_btnStart_clicked()
{
    emit sigStart();
}

void MainWindow::on_btnStop_clicked()
{
    qDebug() << "Main thread send signal";
    emit sigStop();
    qDebug() << "Main thread end.";
}

目的——期望结果:

现在开始玩上面的代码,先说理想情况,我希望多次点击start产生循环嵌套以后,点击stop时,子线程逐级退出循环,而且主线程能正确获得已经结束的时机,从而再执行清理代码的时候不会造成野循环。

按照上面代码输出debug文本,我希望是这个顺序:

Main thread send signal.//主线程发信号
Sub thread: stopping...//子线程开始自我终结
Sub thread: event loop exists level:*//可能会有多级
Sub thread: end.//子线程结束
Main thread end.//主线程结束

上面只是理想,如果就按照上面的代码执行,效果不会实现,槽的执行方式默认时队列方式,它会先把主线程执行完,再执行子线程,这样在主线程写清理代码的时机就很重要,如果操作不当,会造成子线程野循环,报错。

Main thread send signal.//主线程发信号
Main thread end.//主线程结束
Sub thread: stopping...//子线程开始终结
Sub thread: event loop exists level:  3
Sub thread: event loop exists level:  2
Sub thread: event loop exists level:  1
Sub thread: end.//子线程结束

就如上面这样,显然不是想要的。如果一定要这样用,在子线程结束时还要给主线程发信号来触发清理操作。

应用——意义:

之所以要这样做,是希望主线程能够在终结子线程操作的时候能够保持时序,终结子线程行为之后,可以马上执行清理操作,而不会报错。主线程有一个“等待子线程完成”的动作。

如果不这样,发完信号就清理,子线程还没来得及停止所有操作,就已经被释放内存,内存倒是没泄露,可是正在执行的循环没有跳出,就是野循环,早晚会耗尽资源卡死,甚至直接报错。

所以有下面几种处理方式。

方式——阻塞连接:

所谓阻塞连接,就是信号槽的connect函数的最后一个参数使用Qt::BlockingQueuedConnection。按照阻塞连接的方式改一下主线程代码:

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "obj.h"
#include 
#include 
#include 

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

    m_obj = new Obj;
    connect(this, SIGNAL(sigStart()), m_obj, SLOT(onStart()));

    //使用阻塞连接方式,就改这一个地方,只是加了一个参数
    connect(this, SIGNAL(sigStop()), m_obj, SLOT(onStop()), Qt::BlockingQueuedConnection);

    m_obj->setParent(nullptr);

    QThread *thd = new QThread;
    thd->start();

    m_obj->moveToThread(thd);
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::on_btnStart_clicked()
{
    emit sigStart();
}

void MainWindow::on_btnStop_clicked()
{
    qDebug() << "Main thread send signal.";
    emit sigStop();
    qDebug() << "Main thread end.";
}

只在connect的时候加了一个参数而已,再看效果。

Main thread send signal.//主线程发信号
Sub thread: stopping...//子线程执行槽,执行完槽回到eventloop
Main thread end.//主线程继续结束
Sub thread: event loop exists level:  3//子线程退出逐级循环
Sub thread: event loop exists level:  2
Sub thread: event loop exists level:  1
Sub thread: end.//子线程结束

看效果有点那个意思,但是子线程一旦执行完槽函数,它就回到自己最近的一层事件循环,这就算处理完消息队列了,所以接着会执行主线程的代码。因此还无法实现最初的想法。所以就有了使用条件变量的方法。

这里要说明,因为本篇文章我以事件循环嵌套为基础讨论,所以看不出阻塞队列方式的优点。事实上,如果子线程中只有槽函数需要主线程等待,那么使用阻塞队列方式,更加简洁高效。

方式——条件变量:

子线程对象定义,加入条件变量和响应的锁:

#ifndef OBJ_H
#define OBJ_H

#include 
#include 
#include 

class Obj : public QObject
{
    Q_OBJECT
public:
    Obj();

    void f_Caller_Wait_Prepare();//用于主线程阻塞时获得锁
    void f_Caller_Wait();//用于主线程阻塞
    void f_Caller_Wakeup();//用于主线程唤醒

private slots:
    void onStart();
    void onStop();

private:
    QWaitCondition      m_condition;//条件变量
    QMutex              m_mutex;//互斥锁
    bool m_bStop = true;
    int m_iLoopLevel = 0;
    void f_Start();
};

#endif // OBJ_H

子线程实现:

#include "obj.h"
#include 
#include 
#include 

Obj::Obj()
{

}

void Obj::f_Start()
{
    m_bStop = false;
    m_iLoopLevel++;

    while (true)
    {
        QCoreApplication::processEvents();

        if (m_bStop)
        {
            break;
        }

        QThread::msleep(200);
    }

    qDebug() << "Sub thread: event loop exists level: " << m_iLoopLevel;
    m_iLoopLevel--;

    if (m_iLoopLevel == 0)
    {
        f_Caller_Wakeup();//退出最后一层循环后,唤醒主线程
        qDebug() << "Sub thread: end.";
    }
}

void Obj::onStart()
{
    f_Start();
}

void Obj::onStop()
{
    qDebug() << "Sub thread: stopping...";
    m_bStop = true;
}

void Obj::f_Caller_Wait_Prepare()
{
    m_mutex.lock();
}

void Obj::f_Caller_Wait()
{
    qDebug() << "Main thread wait...";
    m_condition.wait(&m_mutex);
    m_mutex.unlock();
}

void Obj::f_Caller_Wakeup()
{
    qDebug() << "Main thread continue.";
    m_mutex.lock();
    m_condition.wakeAll();
    m_mutex.unlock();
}

主线程实现:

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "obj.h"
#include 
#include 
#include 

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

    m_obj = new Obj;
    connect(this, SIGNAL(sigStart()), m_obj, SLOT(onStart()));
    connect(this, SIGNAL(sigStop()), m_obj, SLOT(onStop()));//使用默认连接方式
    m_obj->setParent(nullptr);

    QThread *thd = new QThread;
    thd->start();

    m_obj->moveToThread(thd);
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::on_btnStart_clicked()
{
    emit sigStart();
}

void MainWindow::on_btnStop_clicked()
{
    qDebug() << "Main thread send signal.";
    m_obj->f_Caller_Wait_Prepare();//获得锁,保证emit之后马上wait,不会被调度插队
    emit sigStop();
    m_obj->f_Caller_Wait();//主线程等待
    qDebug() << "Main thread end.";
}

执行效果如下:

Main thread send signal.//主线程发信号
Main thread wait...//主线程等待
Sub thread: stopping...//子线程开始终结
Sub thread: event loop exists level:  6
Sub thread: event loop exists level:  5
Sub thread: event loop exists level:  4
Sub thread: event loop exists level:  3
Sub thread: event loop exists level:  2
Sub thread: event loop exists level:  1
Main thread continue.//唤醒主线程
Sub thread: end.//子线程终结
Main thread end.//主线程终结

这就实现最初的想法了。

方式——子线程回复信号:

主线程发完信号之后不要马上清理,子线程完成后发信号通知主线程已经结束,再清理。下面试试这种方式。

子线程加一个sigStopped信号,发给主线程。主要看一下实现代码。

子线程实现:

#include "obj.h"
#include 
#include 
#include 

Obj::Obj()
{

}

void Obj::f_Start()
{
    m_bStop = false;
    m_iLoopLevel++;

    while (true)
    {
        QCoreApplication::processEvents();

        if (m_bStop)
        {
            break;
        }

        QThread::msleep(200);
    }

    qDebug() << "Sub thread: event loop exists level: " << m_iLoopLevel;
    m_iLoopLevel--;

    if (m_iLoopLevel == 0)
    {
        qDebug() << "Sub thread: end.";
        emit sigStopped();//退出最后一层循环后,通知主线程
    }
}

void Obj::onStart()
{
    f_Start();
}

void Obj::onStop()
{
    qDebug() << "Sub thread: stopping...";
    m_bStop = true;
}

主线程实现:

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "obj.h"
#include 
#include 

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

    m_obj = new Obj;
    connect(this, SIGNAL(sigStart()), m_obj, SLOT(onStart()));
    connect(this, SIGNAL(sigStop()), m_obj, SLOT(onStop()));
    connect(m_obj, SIGNAL(sigStopped()), this, SLOT(onSubStopped()));//增加一个回复连接
    m_obj->setParent(nullptr);

    QThread *thd = new QThread;
    thd->start();

    m_obj->moveToThread(thd);
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::on_btnStart_clicked()
{
    emit sigStart();
}

void MainWindow::on_btnStop_clicked()
{
    qDebug() << "Main thread send signal.";
    emit sigStop();//发送完信号什么也不做,等待子线程回复
}

void MainWindow::onSubStopped()//子线程发回已终止信号之后被触发
{
    qDebug() << "Main thread end.";
}

执行效果:

Main thread send signal.//主线程发信号
Sub thread: stopping...//子线程开始自我终结
Sub thread: event loop exists level:  3
Sub thread: event loop exists level:  2
Sub thread: event loop exists level:  1
Sub thread: end.//子线程终止
Main thread end.//主线程终止

看效果还是不错的。

看起来这种完全异步方式更灵活,但是看情况,太多的异步交互不太容易阅读代码。

毕竟是异步的,多线程执行受os调度影响,一定要想清楚时序。

结论:

所以我个人看法是:

如果子线程需要父线程等待执行的,只有子线程的槽函数。就用阻塞连接方式,只是加一个参数,简洁高效。

如果子线程工作的终止可能单方面发生, 让子线程回复一个完成信号的方式更加灵活机动,完全异步实现,消耗资源也少。比如:网络通信中的客户端,它可能由于自己的原因掉线了,就需要主动通知服务端。

如果是纯粹的主从模式,子线程的终止操作,只受命于父线程。亦即,主线程对于子线程有绝对控制权的时候,可以使用条件变量。因为主线程需要主动有“等”这个动作。条件变量可以严格控制时序。手动控制它什么时候等待,什么时候被唤醒,确保时序万无一失。比如:控制器和执行器之间。

你可能感兴趣的:(qt/c++,qt,开发语言)