• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

QT从入门到入土(四)——多线程

开发技术 开发技术 2小时前 3次浏览

引言

前面几篇已经对C++的线程做了简单的总结,浅谈C++11中的多线程(三) – 唯有自己强大 – 博客园 (cnblogs.com)。本篇着重于Qt多线程的总结与实现。

跟C++11中很像的是,Qt中使用QThread来管理线程,一个QThread对象管理一个线程,在使用上有很多跟C++11中相似的地方,但更多的是Qt中独有的内容。另外,QThread对象也有消息循环exec()函数,即每个线程都有一个消息循环,用来处理自己这个线程的事件。


一,知识回顾

首先先来回顾一下一些知识点:

1,为什么需要多线程?

解决耗时操作堵塞整个程序的问题,一般我们会将耗时的操作放入子线程中

2,进程和线程的区别:

进程:一个独立的程序,拥有独立的虚拟地址空间,要和其他进程通信,需要使用进程通信的机制。

线程:没有自己的资源,都是共享进程的虚拟地址空间,多个线程通信存在隐患。

ps:在操作系统每一个进程都拥有独立的内存空间,线程的开销远小于进程,一个进程可以拥有多个线程。(因此我们常用多线程并发,而非多进程并发

为了更容易理解多线程的作用,先看一个实例:

在主线程中运行一个10s耗时的操作。(通过按钮来触发)

QT从入门到入土(四)——多线程

void Widget::on_pushButton_clicked()
{
 QThread::sleep(10);
}

可以看到程序运行过程中,整个线程都在响应10秒的耗时操作,对于线程的消息循环exec()函数就未响应了(就是你在这个过程中拖动界面是无反应的)

QT从入门到入土(四)——多线程

 二,Qt中实现多线程的两种方法

🧡🧡2.1.派生QThread类对象的方法(重写Run函数)

首先,以文字形式来说明需要哪几个步骤。

  1. 自定义一个自己的类,使其继承自QThread类;
  2. 在自定义类中覆写QThread类中的虚函数run()。

这很可能就是C++中多态的使用。补充一点:QThread类继承自QObject类。

这里要重点说一下run()函数了。它作为线程的入口,也就是线程从run()开始执行,我们打算在线程中完成的工作都要写在run()函数中,个人认为可以把run()函数理解为线程函数。这也就是子类覆写基类的虚函数,基类QThread的run()函数只是简单启动exec()消息循环,关于这个exec()后面有很多东西要讲,请做好准备。
那么我们就来尝试用多线程实现10s耗时的操作:(用按钮触发)

1️⃣在编辑好ui界面后,先创建一个workThread1的类。(继承自QThread类(可以先继承Qobject再去改成QThread))

2️⃣在workThread1的类中重写run函数

在workThread1.h的public类声明run函数: void run();

在workThread1.cpp中重写run函数(打印子线程的ID):

#include "workthread1.h"
#include<QDebug>
workThread1::workThread1(QObject *parent) : QThread(parent)
{

}
//重写run函数
void workThread1::run()
{
    qDebug()<<"当前线程ID:"<<QThread::currentThreadId();
    qDebug()<<"开始执行线程";
     QThread::sleep(10);
     qDebug()<<"线程结束";
     
}

3️⃣在widget.cpp中的button的click事件中打印主线程ID:

void Widget::on_pushButton_clicked()
{
 qDebug()<<"当前线程ID:"<<QThread::currentThreadId();
}

4️⃣启动子线程

在widget.h的private中声明线程 workThread1 *thread1;(需添加#include<workthread1.h>)

在widget.cpp中初始化该线程,并启动:

#include "widget.h"
#include "ui_widget.h"
#include<QThread>
#include<QDebug>
Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
   thread1=new workThread1(this);//初始化子线程

}

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


void Widget::on_pushButton_clicked()
{
 qDebug()<<"当前线程ID:"<<QThread::currentThreadId();
 thread1->start();//启动子线程
}

可以实现,在执行耗时操作时也可拖动界面。

QT从入门到入土(四)——多线程

 QT从入门到入土(四)——多线程

需要注意的是:

使用QThread::currentThreadId()来查看当前线程的ID,无论是子线程还是主线程,不同线程其ID是不同的。注意,这是一个静态函数,因此可以不经过对象来调用。

创建的workThread1类的执行实际上是在主线程里的,只有run函数内的程序才会在子线程中执行!(即QThread只是线程的管理类,只有run()才是我们的线程函数)

因此在QThread(即创建的类)中的成员变量属于主线程,在访问前需要判断访问是否安全。run()中创建的变量属于子线程。

线程之间共享内存是不安全的(由于多线程争夺资源会影响数据安全问题),解决的办法就是要上锁。


关于互斥锁

互斥锁是一种简单的加锁的方法来控制对共享资源的访问。只要某一个线程上锁了,那么就会强行霸占公共资源的访问权,其他的线程无法访问直到这个线程解锁了,从而保护共享资源

在Qt中的互斥锁常用两种方式:

  • QMutex类下的lock(上锁)和unlcok(解锁)
//需要在头文件中引用#include<QMutex>
//并在头文件的private中声明QMutex mutex;


mutex.lock() public_value++;//公共成员变量 mutex.unlock();
  • QMutexLocker类下的lock(上锁后,当执行析构函数时会自动解锁)
//需要在头文件中引用#include<QMutexLocker>和include<QMutex>
//并在头文件的private中声明QMutex mutex;

QMutexLocker lock(&mutex);//执行构造函数时执行mutex.lock()
public_value++;

//执行析构函数时执行mutex.unlock()

 


关于exec()消息循环

个人认为,exec()这个点太重要了,同时还不太容易理解。

比如下面的代码中有两个exec(),我们讲“一山不容二虎”,放在这里就是说,一个线程中不能同时运行两个exec(),否则就会造成另一个消息循环得不到消息。像QDialog模态窗口中的exec()就是因为在主线程中同时开了两个exec(),导致主窗口的exec()接收不到用户的消息了。但是!但是!但是!我们这里却没有任何问题,因为它们没有出现在同一个线程中,一个是主线程中的exec(),一个是子线程中的exec()。

#include <QApplication>
#include <QThread>
#include <QDebug>
 
class MyThread:public QThread
{
    public:
        void run()
        {
            qDebug()<<"child thread begin"<<endl;
            qDebug()<<"child thread"<<QThread::currentThreadId()<<endl;
            QThread::sleep(5);
            qDebugu()<<"QThread end"<<endl;
            this->exec();
        }
};
 
int main(int argc,char ** argv) //mian()作为主线程
{
    QApplication app(argc,argv);
 
    MyThread thread; //创建一个QThread派生类对象就是创建了一个子线程
    thread.start(); //启动子线程,然后会自动调用线程函数run()
 
    qDebug()<<"main thread"<<QThread::currentThreadId()<<endl;
    QThread::sleep(5);
    qDebugu()<<"main thread"<<QThread::currentThreadId()<<endl;
 
    thread.quit(); //使用quit()或者exit()使得子线程能够退出消息循环,而不至于陷在子线程中
    thread.wait(); //等待子线程退出,然后回收资源
                   //thread.wait(5000); //设定等待的时间
    
    return app.exec();    
}

如果run()函数中没有执行exec()消息循环函数,那么run()执行完了也就意味着子线程退出了。一般在子线程退出的时候需要主线程去回收资源,可以调用QThread的wait(),使主线程等待子线程退出,然后回收资源。这里wait()是一个阻塞函数,有点像C++11中的join()函数。

但是!但是!但是!run()函数中调用了exec()函数,exec()是一个消息循环,也可以叫做事件循环,也是会阻塞的,相当于一个死循环使子线程卡在这里永不退出,必须调用QThread的quit()函数或者exit()函数才可以使子线程退出消息循环,并且有时还不是马上就退出,需要等到CPU的控制权交给线程的exec()。

所以先要thread.quit();使退出子线程的消息循环, 然后thread.wait();在主线程中回收子线程的资源。

值得注意的有两点:子线程的exet()消息循环必须在run()函数中调用;如果没有消息循环的话,则没有必要调用quit( )或者exit(),因为调用了也不会起作用。

第一种创建线程的方式需要在run()中显式调用exec(),但是exec()有什么作用呢,目前还看不出来,需要在第二种创建线程的方式中才能知道。


 💜💜2.2.使用信号与槽方式来实现多线程

 刚讲完使用QThread派生类对象的方法创建线程,现在就要来说它一点坏话。这种方法存在一个局限性,只有一个run()函数能够在线程中去运行,但是当有多个函数在同一个线程中运行时,就没办法了,至少实现起来很麻烦。所以,当当当当,下面将介绍第二种创建线程的方式:使用信号与槽的方式也就是把在线程中执行的函数(我们可以称之为线程函数)定义为一个槽函数。

仍然是首先以文字形式说明这种方法的几个步骤。

注意:必须通过发射信号来让槽函数在子线程中执行,发射的信号存放在子线程消息队列中。要知道发射的信号会经过一个包装,记录其发送者和接收者等信息,操作系统会根据该信号的接收者将信号放在对应线程的消息队列中。

  1. 继承QObject来自定义一个类,该类中实现一个槽函数,也就是线程函数,实现线程要完成的工作;
  2. 在主线程(main函数)中实例化一个QThread对象,仍然用来管理子线程;
  3. 用继承自QObject的自定义类来实例化一个对象,并通过moveToThread将自己放到线程QThread对象中;
  4. 使用connect()函数链接信号与槽,因为一会儿线程启动时会发射一个started()信号;
  5. 调用QThread对象的start()函数启动线程,此时会发出一个started()信号,然后槽函数就会在子线程中执行了。

代码实例:

1️⃣在编辑好ui界面后,先创建一个workThread1的类。(继承自QThread类),并定义槽函数(子线程执行的程序都可以放在槽函数中)

//workThread1.cpp(现在workThread1.h中声明槽函数)

void
workThread1:: doWork() { qDebug()<<"当前线程ID:"<<QThread::currentThreadId(); qDebug()<<"开始执行"; QThread::sleep(10); qDebug()<<"结束执行"; }

2️⃣再主线程中(widget.cpp)实例化一个QThread对象thread。

 //需要引用#include<QThread>
QThread *thread=new QThread();

3️⃣在workThread1的类中实例化一个对象thread1,并通过moveToThread将自己放到线程QThread对象中

采用在widget.h中声明,在widget中实例化(上面的实例化是直接实例化,这里需要把thread1声明在private中了)

  //widget.h中的private

workThread1 *thread1;
  //widget.cpp中

  thread1=new workThread1(this);//初始化
thread1->moveTOThread(thread);//将自定义的类的对象放入线程QThread对象中

4️⃣在按钮的click事件中中打印主线程ID。

void Widget::on_pushButton_clicked()
{
    qDebug()<<"当前线程ID(主线程):"<<QThread::currentThreadId();     
}

5️⃣在widget.cpp中将按钮事件(信号)连接槽函数(即子线程),并运行线程thread。

在运行槽函数时,不能在此直接调用(如:thread1->doWork())。应该使用信号与槽的方法(即用connect连接)

#include "widget.h"
#include "ui_widget.h"
#include<QThread>
#include<QDebug>

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
//不能指定自定义类的对象的父类为widget,即没有this(很重要!!!!) thread1
=new workThread1();//初始化 QThread *thread=new QThread(this); thread1->moveToThread(thread);
//线程结束时清理线程内存
connect(thread,&QThread::finished,thread,&QThread::deleteLater);
//将按钮事件(信号)绑定槽函数 connect(ui
->pushButton,&QPushButton::clicked,thread1,&workThread1::doWork);
//线程启动 thread
->start(); } Widget::~Widget() { delete ui; } void Widget::on_pushButton_clicked() { qDebug()<<"当前线程ID(主线程):"<<QThread::currentThreadId(); }

也可以实现,在执行耗时操作时也可拖动界面。

QT从入门到入土(四)——多线程

QT从入门到入土(四)——多线程

 一般来说(这些程序都是要放在workThread1中的)

workThread1::workThread1(QObject *parent) : QObject(parent)
{
    QThread *thread=new QThread(this);
    moveToThread(thread);
    connect(thread,&QThread::finished,thread,&QThread::deleteLater);
    thread->start();
}

在主程序运行:

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    thread1=new workThread1();//初始化
    connect(ui->pushButton,&QPushButton::clicked,thread1,&workThread1::doWork);

}

特别需要注意的是(爬坑记录):

一号坑:子线程中操作UI

Qt创建的子线程中是不能对UI对象进行任何操作的,即QWidget及其派生类对象,这个是我掉的第一个坑。可能是由于考虑到安全性的问题,所以Qt中子线程不能执行任何关于界面的处理,包括消息框的弹出。正确的操作应该是通过信号槽,将一些参数传递给主线程,让主线程(也就是Controller)去处理。
 
二号坑:自定义的类不能指定父对象
比如上面程序中的:(不能指定自定义类对象为widget,即不可以加this)

thread1=new workThread1();//初始化

 三号坑:信号的参数问题

 这个就实属有毒,搞了我好久。这个涉及到了Qt的元对象系统(Meta-Object System)和信号槽机制。
元对象系统即是提供了Qt类对象之间的信号槽机制的系统。要使用信号槽机制,类必须继承自QObject类,并在私有声明区域声明Q_OBJECT宏。当一个cpp文件中的类声明带有这个宏,就会有一个叫moc工具的玩意创建另一个以moc开头的cpp源文件(在debug目录下),其中包含了为每一个类生成的元对象代码。

QT从入门到入土(四)——多线程

在使用connect函数的时候,我们一般会把最后一个参数忽略掉。这时候我们需要看下函数原型:

[static] QMetaObject::Connection QObject::connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type = Qt::AutoConnection)

可以看到,最后一个参数代表的是连接的方式。

QT从入门到入土(四)——多线程

我们一般会用到方式是有三种

  • 自动连接(AutoConnection),默认的连接方式。如果信号与槽,也就是发送者与接受者在同一线程,等同于直接连接;如果发送者与接受者处在不同线程,等同于队列连接。

  • 直接连接(DirectConnection)。当信号发射时,槽函数立即直接调用。无论槽函数所属对象在哪个线程,槽函数总在发送者所在线程执行。

  • 队列连接(QueuedConnection)。当控制权回到接受者所在线程的事件循环时,槽函数被调用。这时候需要将信号的参数塞到信号队列里。槽函数在接受者所在线程执行。

所以在线程间进行信号槽连接时,使用的是队列连接方式。在项目中,我定义的信号和槽的参数是这样的:

signals:
    //自定义发送的信号
    void myThreadSignal(const int, string, string, string, string);

貌似没什么问题,然而实际运行起来槽函数根本就没有被调用,程序没有崩溃,VS也没报错。在查阅了N多博客和资料中才发现,在线程间进行信号槽连接时,参数不能随便写。

为什么呢?我的后四个参数是标准库中的string类型,这不是元对象系统内置的类型,也不是c++的基本类型,系统无法识别,然后就没有进入信号槽队列中了,自然就会出现问题。解决方法有三种,最简单的就是使用Qt的数据类型了

signals:
    //自定义发送的信号
    void myThreadSignal(const int, QString, QString, QString, QString);

第二种方法就是往元对象系统里注册这个类型。注意,在qRegisterMetaType函数被调用时,这个类型应该要确保已经被完好地定义了。

qRegisterMetaType<MyClass>("MyCl方法三是改变信号槽的连接方式,将默认的队列连接方式改为直接连接方式,这样的话信号的参数直接进入槽函数中被使用,槽函数立刻调用,不会进入信号槽队列中。但这种方式官方认为有风险,不建议使用。ss");

方法三是改变信号槽的连接方式,将默认的队列连接方式改为直接连接方式,这样的话信号的参数直接进入槽函数中被使用,槽函数立刻调用,不会进入信号槽队列中。但这种方式官方认为有风险,不建议使用。

connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::DirectConnection)

🧡🧡总结一下:

  • 一定要用信号槽机制,别想着直接调用,你会发现并没有在子线程中执行。

  • 自定义的类不能指定父对象,因为moveToThread函数会将线程对象指定为自定义的类的父对象,当自定义的类对象已经有了父对象,就会报错。

  • 当一个变量需要在多个线程间进行访问时,最好加上voliate关键字,以免读取到的是旧的值。当然,Qt中提供了线程同步的支持,比如互斥锁之类的玩意,使用这些方式来访问变量会更加安全。

 


程序员灯塔
转载请注明原文链接:QT从入门到入土(四)——多线程
喜欢 (0)