引言
前面几篇已经对C++的线程做了简单的总结,浅谈C++11中的多线程(三) - 唯有自己强大 - 博客园 (cnblogs.com)。本篇着重于Qt多线程的总结与实现。
跟C++11中很像的是,Qt中使用QThread来管理线程,一个QThread对象管理一个线程,在使用上有很多跟C++11中相似的地方,但更多的是Qt中独有的内容。另外,QThread对象也有消息循环exec()函数,即每个线程都有一个消息循环,用来处理自己这个线程的事件。
一,知识回顾
首先先来回顾一下一些知识点:
1,为什么需要多线程?
解决耗时操作堵塞整个程序的问题,一般我们会将耗时的操作放入子线程中
2,进程和线程的区别:
进程:一个独立的程序,拥有独立的虚拟地址空间,要和其他进程通信,需要使用进程通信的机制。
线程:没有自己的资源,都是共享进程的虚拟地址空间,多个线程通信存在隐患。
ps:在操作系统每一个进程都拥有独立的内存空间,线程的开销远小于进程,一个进程可以拥有多个线程。(因此我们常用多线程并发,而非多进程并发)
为了更容易理解多线程的作用,先看一个实例:
在主线程中运行一个10s耗时的操作。(通过按钮来触发)
#include "threadtest.h"
#include"qthread.h"
Threadtest::Threadtest(QWidget* parent)
: QMainWindow(parent)
{
ui.setupUi(this);
connect(ui.btn_start, &QPushButton::clicked, this, &Threadtest::on_pushButton_clicked);
}
void Threadtest::on_pushButton_clicked()
{
QThread::sleep(10);//主线程
}
可以看到程序运行过程中,整个线程都在响应10秒的耗时操作,对于线程的消息循环exec()函数就未响应了(就是你在这个过程中拖动界面是无反应的)
二,线程类 QThread
Qt 中提供了一个线程类,通过这个类就可以创建子线程了,Qt 中一共提供了两种创建子线程的方式,后边会依次介绍其使用方式。先来看一下这个类中提供的一些常用 API 函数:
- 2.1 常用共用成员函数
// QThread 类常用 API
// 构造函数
QThread::QThread(QObject *parent = Q_NULLPTR);
// 判断线程中的任务是不是处理完毕了
bool QThread::isFinished() const;
// 判断子线程是不是在执行任务
bool QThread::isRunning() const;
// Qt中的线程可以设置优先级
// 得到当前线程的优先级
Priority QThread::priority() const;
void QThread::setPriority(Priority priority);
优先级:
QThread::IdlePriority --> 最低的优先级
QThread::LowestPriority
QThread::LowPriority
QThread::NormalPriority
QThread::HighPriority
QThread::HighestPriority
QThread::TimeCriticalPriority
QThread::InheritPriority --> 最高的优先级, 默认是这个
// 退出线程, 停止底层的事件循环
// 退出线程的工作函数
void QThread::exit(int returnCode = 0);
// 调用线程退出函数之后, 线程不会马上退出因为当前任务有可能还没有完成, 调回用这个函数是
// 等待任务完成, 然后退出线程, 一般情况下会在 exit() 后边调用这个函数
bool QThread::wait(unsigned long time = ULONG_MAX);
- 2.2 信号槽
// 和调用 exit() 效果是一样的
// 代用这个函数之后, 再调用 wait() 函数
[slot] void QThread::quit();
// 启动子线程
[slot] void QThread::start(Priority priority = InheritPriority);
// 线程退出, 可能是会马上终止线程, 一般情况下不使用这个函数
[slot] void QThread::terminate();
// 线程中执行的任务完成了, 发出该信号
// 任务函数中的处理逻辑执行完毕了
[signal] void QThread::finished();
// 开始工作之前发出这个信号, 一般不使用
[signal] void QThread::started();
- 2.3静态函数
// 返回一个指向管理当前执行线程的QThread的指针
[static] QThread *QThread::currentThread();
// 返回可以在系统上运行的理想线程数 == 和当前电脑的 CPU 核心数相同
[static] int QThread::idealThreadCount();
// 线程休眠函数
[static] void QThread::msleep(unsigned long msecs); // 单位: 毫秒
[static] void QThread::sleep(unsigned long secs); // 单位: 秒
[static] void QThread::usleep(unsigned long usecs); // 单位: 微秒
三,Qt中实现多线程的两种方法
🧡🧡3.1.派生QThread类对象的方法(重写Run函数)
首先,以文字形式来说明需要哪几个步骤。
- 自定义一个自己的类,使其继承自QThread类;
- 在自定义类中覆写QThread类中的虚函数run()。
这很可能就是C++中多态的使用。补充一点:QThread类继承自QObject类。
这里要重点说一下run()函数了。它作为线程的入口,也就是线程从run()开始执行,我们打算在线程中完成的工作都要写在run()函数中,个人认为可以把run()函数理解为线程函数。这也就是子类覆写基类的虚函数,基类QThread的run()函数只是简单启动exec()消息循环,关于这个exec()后面有很多东西要讲,请做好准备。那么我们就来尝试用多线程实现10s耗时的操作:(用按钮触发)
- 1️⃣在编辑好ui界面后,先创建一个workThread的类。(继承自QThread类)
![](https://i-blog.csdnimg.cn/blog_migrate/6dd7ec985e1242997006eb456793345e.png)
- 2️⃣在workThread1的类中重写run函数
在workThread.h的声明run函数:
#include <qthread.h>
class workThread : public QThread
{
public:
void run();
};
在workThread.cpp中重写run函数(并打印子线程的ID):
#include "workThread.h"
#include"qdebug.h"
workThread::workThread(QObject* parent)
{
}
//重写run函数
void workThread::run()
{
qDebug() << "当前子线程ID:" << QThread::currentThreadId();
qDebug() << "开始执行线程";
QThread::sleep(10);
qDebug() << "线程结束";
}
- 3️⃣在主类中启动线程
threadtest.h中声明线程和按钮事件
#include <QtWidgets/QMainWindow>
#include "ui_threadtest.h"
#include"workThread.h"
#pragma execution_character_set("utf-8")
class Threadtest : public QMainWindow
{
Q_OBJECT
public:
Threadtest(QWidget *parent = Q_NULLPTR);
private:
Ui::ThreadtestClass ui;
void btn_clicked();
workThread* thread;
};
threadtest.cpp中实现,并启动子线程线程
#include "threadtest.h"
#include"qthread.h"
#include"qdebug.h"
Threadtest::Threadtest(QWidget* parent)
: QMainWindow(parent)
{
ui.setupUi(this);
connect(ui.btn_start, &QPushButton::clicked, this, &Threadtest::btn_clicked);
thread = new workThread(this);
}
void Threadtest::btn_clicked()
{
qDebug() << "主线程id:" << QThread::currentThreadId();
thread->start();//启动子线程
}
可以实现,在执行耗时操作时也可拖动界面。
需要注意的是:
在主程序中添加workThread类的头文件时,需要将workThread.h放在threadtest.h中(不然会报错!!!!)
![](https://i-blog.csdnimg.cn/blog_migrate/1954389e50905889498a24ef8a0a5212.png)
使用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()有什么作用呢,目前还看不出来,需要在第二种创建线程的方式中才能知道。
💜💜3.2.使用信号与槽方式来实现多线程
刚讲完使用QThread派生类对象的方法创建线程,现在就要来说它一点坏话。这种方法存在一个局限性,只有一个run()函数能够在线程中去运行,但是当有多个函数在同一个线程中运行时,就没办法了,至少实现起来很麻烦。所以,当当当当,下面将介绍第二种创建线程的方式:使用信号与槽的方式,也就是把在线程中执行的函数(我们可以称之为线程函数)定义为一个槽函数。
仍然是首先以文字形式说明这种方法的几个步骤。
- 创建一个新的类(mywork),让这个类从 QObject 派生,在这个类中添加一个公共的成员函数(working),函数体就是我们要子线程中执行的业务逻辑
class MyWork:public QObject
{
public:
.......
// 函数名自己指定, 叫什么都可以, 参数可以根据实际需求添加
void working();
}
- 在主线程中创建一个 QThread 对象,这就是子线程的对象
QThread* sub = new QThread;
- 在主线程中创建工作的类对象(千万不要指定给创建的对象指定父对象)
MyWork* work = new MyWork(this); // error
MyWork* work = new MyWork; // ok
- 将 MyWork 对象移动到创建的子线程对象中,需要调用 QObject 类提供的 moveToThread() 方法
// void QObject::moveToThread(QThread *targetThread);
// 如果给work指定了父对象, 这个函数调用就失败了
// 提示: QObject::moveToThread: Cannot move objects with a parent
work->moveToThread(sub); // 移动到子线程中工作
- 启动子线程,调用 start(), 这时候线程启动了,但是移动到线程中的对象并没有工作
- 调用 MyWork 类对象的工作函数,让这个函数开始执行,这时候是在移动到的那个子线程中运行的
代码实例:
- 1️⃣创建一个workThread的类。(继承自QThread类)
定义槽函数(子线程执行的程序都可以放在槽函数中)
//workThread.cpp(先在workThread.h中声明槽函数)
void workThread:: doWork()
{
qDebug()<<"当前线程ID:"<<QThread::currentThreadId();
qDebug()<<"开始执行";
QThread::sleep(10);
qDebug()<<"结束执行";
}
- 2️⃣主线程中分别对workThread类和QTread类实例化
在threadtest.h中声明
#include <QtWidgets/QMainWindow>
#include "ui_threadtest.h"
#include"workThread.h"
#include"qthread.h"
#pragma execution_character_set("utf-8")
class Threadtest : public QMainWindow
{
Q_OBJECT
public:
Threadtest(QWidget *parent = Q_NULLPTR);
private:
Ui::ThreadtestClass ui;
void btn_clicked();
workThread* thread; //实例化workThread类
QThread* qthread; //实例化QThread类
};
在threadtest.cpp中实现并通过moveToThread将自己放到线程QThread对象中,最后启动线程
#include "threadtest.h"
#include"qthread.h"
#include"qdebug.h"
Threadtest::Threadtest(QWidget* parent)
: QMainWindow(parent)
{
ui.setupUi(this);
//不能指定自定义类的对象的父类为widget,即没有this(很重要!!!!)
thread = new workThread();
qthread1 = new QThread(this);
thread->moveToThread(qthread1);
//线程结束时清理线程内存
connect(qthread1, &QThread::finished, qthread1, &QThread::deleteLater);
//将按钮事件(信号)绑定槽函数
connect(ui.btn_start, &QPushButton::clicked, thread, &workThread::dowork);
//打印主线程
connect(ui.btn_start, &QPushButton::clicked, [=]() {
qDebug() << "主线程id:" << QThread::currentThreadId();
});
//线程启动
qthread1->start();
}
在运行槽函数时,不能在此直接调用(如:thread1->doWork())。而是用connect连接信号和槽
这里将打印主线程和槽函数都绑定在了button按钮的click事件上了。
特别需要注意的是(爬坑记录):
- 子线程中不能操作UI
- 自定义的类不能指定父对象
thread1=new workThread1();//初始化
- QThread和connect的关系
[static] QMetaObject::Connection QObject::connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type = Qt::AutoConnection)
可以看到,最后一个参数代表的是连接的方式。我们一般会用到方式是有三种:
自动连接(AutoConnection):默认的连接方式。如果信号与槽,也就是发送者与接受者在同一线程,等同于直接连接;如果发送者与接受者处在不同线程,等同于队列连接。
直接连接(Direct Connection):当信号发射时,槽函数将直接被调用。无论槽函数所属对象在哪个线程,槽函数都在发射者所在线程执行。
队列连接(Queued Connection):当控制权回到接受者所在线程的事件循环式,槽函数被调用。槽函数在接收者所在线程执行。
因此我们需要注意的是:
- 主线程对象发出信号连接QThread子类的槽函数,QThread子类对象在主线程创建的,无论采用哪种连接方式,槽函数都属在主线程调用。(如果在重写的run函数中调用了槽函数,此时槽函数在次线程执行,注意数据安全)。
- 次线程run中发出信号,槽函数可以是发出信号对象自身的槽函数,自发自收,都是次线程中行。槽函数是QThread子类的槽函数,或者主线程中对象的槽函数,这里的种情况需要你指明run中connect中的连接方式,直连则该槽函数在次线程中执行(可能发生数据安全问题),列队则在主线程执行。
🧡🧡总结一下:
-
一定要用信号槽机制,别想着直接调用,你会发现并没有在子线程中执行。
-
自定义的类不能指定父对象,因为moveToThread函数会将线程对象指定为自定义的类的父对象,当自定义的类对象已经有了父对象,就会报错。
-
当一个变量需要在多个线程间进行访问时,最好加上voliate关键字,以免读取到的是旧的值。当然,Qt中提供了线程同步的支持,比如互斥锁之类的玩意,使用这些方式来访问变量会更加安全。
- 分析发出信号的对象和接受信号对象所在的线程,再通过连接方式,判断槽函数在哪里执行。(小白在使用中就有在run中创建对象-因为多非槽函数都需要在次线程中执行,通过指针引出来,再connect与其他模块交互,指明连接方式为列队形式,所以相关执行都在次线程中执行)。这里记住moveToThread只能将槽函数移到次线程中。
启动多线程的操作思路
如果我们需要实现一个排序操作,即首先获取1000个随机数,然后用冒泡排序法对其进行排序。
方法一:重写run函数
思路:(构建两个子线程,一个用于生成随机数,一个用于冒泡排序,主线程负责调用)
- 新建myThread类,在该类中重写run函数(即生随机数)。需要先接收主线程发送的要生成随机数的个数(scvnum信号)后再进行生成,生成完成以后发送一个sendArray信号
- 新建BubbleSort类,在该类中重写run函数(即冒泡排序算法)。需要先接收已经生成的随机数(rcvArray信号)后再进行排序,排序完成后发送一个finish信号
- 主线程通过stating信号告诉myThread线程要生成的个数,然后myThread线程通过scvnum信号接收,进行生成随机数,然后再发送一个sendArray信号(即生成随机数集合)
- BubbleSort子线程通过rcvArray信号接收sendArray信号(即接收随机数)然后进行冒泡排序,再发送finish信号
- 主线程接收到finish信号后,将排序后的随机数显示在界面上
实现代码:
- 子线程.h
#pragma once
#include"qthread.h"
#include"qvector.h"
//新建随机数类
class myThread :
public QThread
{
Q_OBJECT
public:
myThread(QObject* parent = nullptr);
void scvnum(int num);//接收数字
protected:
void run();
signals:
void sendArray(QVector<int>num);//发送
private:
int m_num;
};
//新建冒泡排序类
class BubbleSort :
public QThread
{
Q_OBJECT
public:
BubbleSort(QObject* parent = nullptr);
void rcvArray(QVector<int>list);//要接收的是排序的数
protected:
void run();
signals:
void finish(QVector<int>list);//排序完成后发送一个finish信号
private:
QVector<int>m_list;
};
- 子线程.cpp
#include "myThread.h"
#include"qelapsedtimer.h"
#include"qdebug.h"
myThread::myThread(QObject* parent) :QThread(parent)
{
}
BubbleSort::BubbleSort(QObject* parent) : QThread(parent)
{
}
void myThread::scvnum(int num)
{
m_num = num;
}
void myThread::run()
{
qDebug() << "child thread id" << QThread::currentThreadId();
QVector<int> list;
QElapsedTimer time;
time.start();
for (int i = 0; i < m_num; i++)
{
list.push_back(qrand() % 100000);
}
int milsec = time.elapsed();
qDebug() << "The number of" << m_num << "generated";
qDebug() << "shared" << milsec << "second";
emit sendArray(list);
}
void BubbleSort::rcvArray(QVector<int> list)
{
m_list = list;
}
void BubbleSort::run()
{
qDebug() << "BubbleSort thread id:" << QThread::currentThreadId();
QElapsedTimer time;
time.start();
int temp;
for (int i = 0; i < m_list.size(); ++i)
{
for (int j = 0; j < m_list.size()-i-1; ++j)
{
if (m_list[j] > m_list[j + 1])
{
temp = m_list[j];
m_list[j] = m_list[j + 1];
m_list[j + 1] = temp;
}
}
}
int milsec = time.elapsed();
qDebug() << "shared" << milsec << "second";
emit finish(m_list);
}
- 主线程.h
#include <QtWidgets/QWidget>
#include"ui_list.h"
class list : public QWidget
{
Q_OBJECT
public:
list(QWidget *parent = Q_NULLPTR);
signals:
void stating(int num);//设置要生成随机数个数
private:
Ui::listClass ui;
};
- 主线程.cpp
#include "list.h"
#include"myThread.h"
list::list(QWidget *parent)
: QWidget(parent)
{
ui.setupUi(this);
//1.创建子线程对象
myThread* thread = new myThread();
BubbleSort* bub_thread = new BubbleSort();
//向子线程发送要生成的随机数个数
connect(this,&list::stating, thread, &myThread::scvnum);
//2启动子线程
connect(ui.pushButton, &QPushButton::clicked, [=]() {
emit stating(1000);//主线程设置子线程随机数的个数
thread->start();
});
connect(thread, &myThread::sendArray, bub_thread, &BubbleSort::rcvArray);
//3接收子线程发送的数据
connect(thread, &myThread::sendArray, [=](QVector<int>list) {
for (int i = 0; i < list.size(); ++i)
{
ui.randlist->addItem(QString::number(list.at(i)));
}
});
connect(thread, &myThread::sendArray, [=](QVector<int>list){
bub_thread->start();
});
connect(bub_thread, &BubbleSort::finish, [=](QVector<int>list) {
for (int i = 0; i < list. size(); ++i)
{
ui.bubblelist->addItem(QString::number(list.at(i)));
}
});
}
实现效果:
![](https://i-blog.csdnimg.cn/blog_migrate/d55ba844e38699c5ca5f639e801795ae.gif)
方法二:moveToThread()
思路:
- 新建myThread类,用于生成随机数(working函数),在接受到主线程的信号后开始生成随机数
- 新建BubbleSort类,用于排序(working函数),在接受到myThread类生成的随机数后开始排序
- 最后显示在界面
代码实现:
- 子线程.h
#pragma once
#include"qthread.h"
#include"qvector.h"
#include"qobject.h"
//新建随机数类
class myThread :
public QObject
{
Q_OBJECT
public:
myThread(QObject* parent = nullptr);
void working(int num);//生成随机数
signals:
void sendArray(QVector<int>num);//发送
private:
int m_num;
};
//新建冒泡排序类
class BubbleSort :
public QObject
{
Q_OBJECT
public:
BubbleSort(QObject* parent = nullptr);
void working(QVector<int>list);//要接收的是排序的数
signals:
void finish(QVector<int>list);//排序完成后发送一个finish信号
};
- 子线程.cpp
#include "myThread.h"
#include"qelapsedtimer.h"
#include"qdebug.h"
myThread::myThread(QObject* parent) :QObject(parent)
{
}
BubbleSort::BubbleSort(QObject* parent) : QObject(parent)
{
}
void myThread::working(int num)
{
qDebug() << "child thread id" << QThread::currentThreadId();
QVector<int> list;
QElapsedTimer time;
time.start();
for (int i = 0; i < num; i++)
{
list.push_back(qrand() % 100000);
}
int milsec = time.elapsed();
qDebug() << "The number of" << m_num << "generated";
qDebug() << "shared" << milsec << "second";
emit sendArray(list);
}
void BubbleSort::working(QVector<int>list)
{
qDebug() << "BubbleSort thread id:" << QThread::currentThreadId();
QElapsedTimer time;
time.start();
int temp;
for (int i = 0; i < list.size(); ++i)
{
for (int j = 0; j < list.size()-i-1; ++j)
{
if (list[j] > list[j + 1])
{
temp = list[j];
list[j] = list[j + 1];
list[j + 1] = temp;
}
}
}
int milsec = time.elapsed();
qDebug() << "shared" << milsec << "second";
emit finish(list);
}
- 主线程.h
#include <QtWidgets/QWidget>
#include"ui_list.h"
class list : public QWidget
{
Q_OBJECT
public:
list(QWidget *parent = Q_NULLPTR);
signals:
void stating(int num);//设置要生成随机数个数
private:
Ui::listClass ui;
};
- 主线程.cpp
#include "list.h"
#include"myThread.h"
list::list(QWidget *parent)
: QWidget(parent)
{
ui.setupUi(this);
//1.创建QThread对象
QThread* thread1 = new QThread;
QThread* thread2 = new QThread;
//2.创建子线程类对象
myThread* myth = new myThread();
BubbleSort* bub = new BubbleSort();
//3通过movetothread将子线程对象移动到QThread对象中
myth->moveToThread(thread1);
bub->moveToThread(thread2);
//4启动子线程
//先向子线程发送要生成的随机数个数
connect(this,&list::stating, myth, &myThread::working);
//再启动子线程
connect(ui.pushButton, &QPushButton::clicked, [=]() {
emit stating(1000);//主线程设置子线程随机数的个数
thread1->start();
});
//将生成好的随机数发送给BubbleSort类
connect(myth, &myThread::sendArray, bub, &BubbleSort::working);
//将生成好的随机数显示在界面
connect(myth, &myThread::sendArray, [=](QVector<int>list) {
for (int i = 0; i < list.size(); ++i)
{
ui.randlist->addItem(QString::number(list.at(i)));
}
});
//发送的同时启动排序算法
connect(myth, &myThread::sendArray, [=](QVector<int>list){
thread2->start();
});
//将排序好的数显示在界面
connect(bub, &BubbleSort::finish, [=](QVector<int>list) {
for (int i = 0; i < list. size(); ++i)
{
ui.bubblelist->addItem(QString::number(list.at(i)));
}
});
}
结论
通过对比,我们可以发现:
- 由于第二种方法,我们可以自定义带参的子线程运行函数,因此代码更加简洁。
- 在第二种方法中,我们还可以随意修改需要在哪个线程中运行,代码也更加灵活。
- 第一种方法适合在线程中处理单一事件,其逻辑简单(只需要新建一个继承自QThread类的对象,重写run函数,然后启动即可),对于需要在一个线程中处理多个事件,还是用第二种方法比较好。
- 为什么不能在第二种方法中,给定义的子线程对象添加父类呢? :由于添加了父类以后就不能再移动到QThread中去了
如何进行线程资源的释放?
- 在new对象时候,直接用this指定其父类(即放入对象数中)
- 在程序最后自行释放资源
connect(this, &list::destroyed, this, [=]() {
thread1->quit();
thread1->wait();
thread1->deleteLater();
thread2->quit();
thread2->wait();
thread2->deleteLater();
myth->deleteLater();
bub->deleteLater();
});