C++客户端Qt开发——多线程编程（一）

多线程编程（一）

①QThread

在Qt中，多线程的处理一般是通过QThread类来实现。

QThread代表一个在应用程序中可以独立控制的线程，也可以和进程中的其他线程共享数据。

QThread对象管理程序中的一个控制线程。

run()	线程的入口函数
start()	通过调用run()开始执行函数，操作系统将根据优先级参数调度线程，如果线程已经在运行，这个函数什么也不做
currentThread()	返回一个指向管理当前执行线程的QThread的指针
isRunning()	如果线程正在运行则返回true，否则返回false
sleep() / msleep() / usleep()	使线程休眠，单位为秒/毫秒/微秒
wait()	阻塞线程，直到满足以下任何一个条件： 与此QThread对象关联的线程已经完成执行（即当它从run(0返回时）。如果线程已经完成，这个函数将返回true。如果线程尚未启动，它也返回true。 已经过了几毫秒。如果时间是ULONG MAX(默认值)，那么等待永远不会超时（线程必须从run()返回)。如果等待超时，此函数将返回false。 这提供了与POSIX pthread_join()函数类似的功能。
terminate()	终止线程的执行。线程可以立即终止，也可以不立即终止，这取决于操作系统的调度策略。在terminate()之后使用QThread:wait()来确保。
finished()	当线程结束时会发出该信号，可以通过该信号来实现线程的清理工作。

②两种多线程使用方式

1>第一种

Qt中提供的多线程的第一种使用方式的特点是：简单

1. 需要创建一个线程类的子类，让其继承QT中的线程类QThread，例如：

class MyThread:public QThread
{......
}

1. 重写父类中的run（）方法，在该函数内部编写子线层要处理的具体的业务流程

class MyThread:public QThread
{......protected:void run(){........}
}

1. 在主线程中new一个子线程对象，在主线程中合适的位置启动子线程，调用start（）方法

MyThread * subThread = new MyThread;subThread->start();

不能在类的外部调用run() 方法启动子线程，在外部调用start()相当于让run()开始运行

当子线程别创建出来之后，父子线程之间的通信可以通过信号槽的方式，注意事项:

• 在Qt中在子线程中不要操作程序中的窗口类型对象, 不允许, 如果操作了程序就挂了
• 只有主线程才能操作程序中的窗口对象, 默认的线程就是主线程, 自己创建的就是子线程

这种在程序中添加子线程的方式是非常简单的，但是也有弊端，假设要在一个子线程中处理多个任务，所有的处理逻辑都需要写到run()函数中，这样该函数中的处理逻辑就会变得非常混乱，不太容易维护。

示例：生成随机数，然后使用冒泡排序和快速排序对其进行处理

创建类的方法就不多说了

mythread.h

#ifndef MYTHREAD_H
#define MYTHREAD_H#include <QThread>
#include<QVector>//生成随机数，将构造类的名字直接改成Generate更明确一些
class Generate : public QThread
{Q_OBJECT
public:explicit Generate(QObject *parent = nullptr);//将主线程传递过来的数保存到m_numvoid recvNum(int num);protected:void run() override;signals:void sendArray(QVector<int>);private:int m_num;};class BubbleSort : public QThread
{Q_OBJECT
public:explicit BubbleSort(QObject *parent = nullptr);//将主线程传递过来的数保存到m_numvoid recvArray(QVector<int> list);protected:void run() override;signals:void finish(QVector<int>);private:QVector<int> m_list;};class QuickSort : public QThread
{Q_OBJECT
public:explicit QuickSort(QObject *parent = nullptr);//将主线程传递过来的数保存到m_numvoid recvArray(QVector<int> list);protected:void run() override;private:void quickSort(QVector<int> &list,int l, int r);signals:void finish(QVector<int>);private:QVector<int> m_list;};#endif // MYTHREAD_H

 mythread.cpp

#include "mythread.h"
#include<QElapsedTimer>
#include<QDebug>Generate::Generate(QObject *parent) : QThread(parent)
{}void Generate::recvNum(int num)
{m_num = num;
}void Generate::run()
{qDebug() << "生成随机数的线程的线程地址：" << QThread::currentThread();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() << "生成" << m_num << "随机数总用时：" << milsec << "毫秒";//发送给主线程emit sendArray(list);
}BubbleSort::BubbleSort(QObject *parent):QThread(parent)
{}void BubbleSort::recvArray(QVector<int> list)
{m_list = list;
}void BubbleSort::run()
{qDebug() << "冒泡排序的线程的线程地址：" << QThread::currentThread();//计时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() << "冒泡排序用时：" << milsec << "毫秒";emit finish(m_list);
}QuickSort::QuickSort(QObject *parent):QThread(parent)
{}void QuickSort::recvArray(QVector<int> list)
{m_list = list;
}void QuickSort::run()
{qDebug() << "快速排序的线程的线程地址：" << QThread::currentThread();//计时QElapsedTimer time;time.start();//快速排序quickSort(m_list,0,m_list.size()-1);int milsec = time.elapsed();qDebug() << "快速排序用时：" << milsec << "毫秒";emit finish(m_list);
}void QuickSort::quickSort(QVector<int> &s, int l, int r)
{if(l<r){int i = l,j = r;int x = s[l];while(i < j){while(i < j && s[j] >= x){j--;}if(i < j){s[i++] = s[j];}while(i < j && s[i] < x){i++;}if(i < j){s[j--] = s[i];}}s[i] = x;quickSort(s,l,i-1);quickSort(s,i+1,r);}
}

 mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H#include <QMainWindow>QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACEclass MainWindow : public QMainWindow
{Q_OBJECTpublic:MainWindow(QWidget *parent = nullptr);~MainWindow();signals:void starting(int num);private:Ui::MainWindow *ui;
};
#endif // MAINWINDOW_H

mainwindow.cpp 

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include<mythread.h>
MainWindow::MainWindow(QWidget *parent): QMainWindow(parent), ui(new Ui::MainWindow)
{ui->setupUi(this);//1.创建子线程对象Generate* gen = new Generate;BubbleSort* bubble = new BubbleSort;QuickSort* quick = new QuickSort;connect(this,&MainWindow::starting,gen,&Generate::recvNum);//2.启动子线程connect(ui->start,&QPushButton::clicked,this,[=](){emit starting(10000);gen->start();});//随机数子线程发送来的数据触发冒泡排序和快速排序接收数据connect(gen,&Generate::sendArray,bubble,&BubbleSort::recvArray);connect(gen,&Generate::sendArray,quick,&QuickSort::recvArray);//接收子线程发送的数据，显示在randlist里，同时启动两个排序子线程connect(gen,&Generate::sendArray,this,[=](QVector<int> list){//启动两个子线程方法bubble->start();quick->start();for (int i=0; i<list.size(); ++i) {ui->randlist->addItem(QString::number(list.at(i)));}});//两个排序子线程处理数据connect(bubble,&BubbleSort::finish,this,[=](QVector<int> list){for (int i=0; i<list.size(); ++i) {ui->bubblelist->addItem(QString::number(list.at(i)));}});connect(quick,&QuickSort::finish,this,[=](QVector<int> list){for (int i=0; i<list.size(); ++i) {ui->quicklist->addItem(QString::number(list.at(i)));}});//资源释放connect(this,&MainWindow::destroyed,this,[=](){//线程释放gen->quit();gen->wait();gen->deleteLater();bubble->quit();bubble->wait();bubble->deleteLater();quick->quit();quick->wait();quick->deleteLater();});}MainWindow::~MainWindow()
{delete ui;
}

main.cpp 

#include "mainwindow.h"#include <QApplication>int main(int argc, char *argv[])
{QApplication a(argc, argv);//向 Qt 元对象系统注册 QVector<int> 类型qRegisterMetaType<QVector<int>>("QVector<int>");MainWindow w;w.show();return a.exec();
}

为什么需要注册类型？

在 Qt 中，某些类型在信号和槽机制中传递时需要被注册。Qt 默认支持一些基本类型（如 int、double、QString 等），但是对于自定义类型或者某些复杂类型（如 QVector<int>），需要显式注册。

• 信号和槽机制: Qt 的信号和槽机制允许对象之间进行通信。当一个信号发出时，连接到该信号的槽函数会被调用。如果你希望信号或槽函数使用 QVector<int> 这样的类型，你需要向 Qt 注册该类型，这样 Qt 才能在运行时识别和处理这种类型。
• QMetaType 系统: Qt 的元对象系统（QMetaType）需要知道所有使用的类型，以便能够在运行时进行类型转换、创建对象和处理信号槽连接等操作。通过 qRegisterMetaType 注册类型，可以确保 Qt 的元对象系统能够识别并处理这种类型。

2>第二种

Qt提供的第二种线程的创建方式弥补了第一种方式的缺点，用起来更加灵活，但是这种方式写起来会相对复杂一些

1. 创建一个新的类，让其从QObject派生（QObject类提供moveToThread()方法）

class MyWork:public QObject
{.......
}

1. 在这个类中添加一个公共的成员函数，函数体就是我们要子线程中执行的业务逻辑

class MyWork:public QObject
{
public:.......// 函数名自己指定, 叫什么都可以, 参数可以根据实际需求添加void working();
}

1. 在主线程中创建一个QThread对象，这就是子线程的对象

QThread* sub = new QThread;

1. 在主线程中创建工作的类对象

MyWork* work = new MyWork(this);    // 错误，这里不能指定this
//如果指定了父类为this，那就无法移动任务到其他的线程中
MyWork* work = new MyWork;          // 正确，什么也不用指定

1. 将MyWork对象移动到创建的子线程对象中，需要调用QObject类提供的moveToThread()方法

// void QObject::moveToThread(QThread *targetThread);
// 如果给work指定了父对象, 这个函数调用就失败了，也就是第四步中提到的this
// 提示： QObject::moveToThread: Cannot move objects with a parent
work->moveToThread(sub);	// 移动到子线程中工作

1. 启动子线程，调用start（），这时候线程启动了，但是移动到线程中的对象并没有工作
2. 调用MyWork类对象的工作函数，让这个函数开始执行，这时候是在移动到的那个子线程中运行的

示例：生成随机数，然后使用冒泡排序和快速排序对其进行处理

直接复制了上边示例的项目，所以这里的类名还是一致的，但是这种方法是从QObject中派生的，命名在这里用于区分代码就好

mythread.h

#ifndef MYTHREAD_H
#define MYTHREAD_H#include <QObject>
#include<QVector>//生成随机数，将构造类的名字直接改成Generate更明确一些
class Generate : public QObject
{Q_OBJECT
public:explicit Generate(QObject *parent = nullptr);void working(int num);signals:void sendArray(QVector<int>);};class BubbleSort : public QObject
{Q_OBJECT
public:explicit BubbleSort(QObject *parent = nullptr);void working(QVector<int> list);signals:void finish(QVector<int>);};class QuickSort : public QObject
{Q_OBJECT
public:explicit QuickSort(QObject *parent = nullptr);void working(QVector<int> list);private:void quickSort(QVector<int> &list,int l, int r);signals:void finish(QVector<int>);};#endif // MYTHREAD_H

 mythread.cpp

#include "mythread.h"
#include<QElapsedTimer>
#include<QDebug>
#include<QThread>Generate::Generate(QObject *parent) : QObject(parent)
{}void Generate::working(int num)
{qDebug() << "生成随机数的线程的线程地址：" << QThread::currentThread();QVector<int> list;//计时QElapsedTimer time;time.start();for(int i=0; i<num; ++i){list.push_back(qrand() % 100000);}int milsec = time.elapsed();qDebug() << "生成" << num << "随机数总用时：" << milsec << "毫秒";//发送给主线程emit sendArray(list);
}BubbleSort::BubbleSort(QObject *parent):QObject(parent)
{}void BubbleSort::working(QVector<int> list)
{qDebug() << "冒泡排序的线程的线程地址：" << QThread::currentThread();//计时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() << "冒泡排序用时：" << milsec << "毫秒";emit finish(list);
}QuickSort::QuickSort(QObject *parent):QObject(parent)
{}void QuickSort::working(QVector<int> list)
{qDebug() << "快速排序的线程的线程地址：" << QThread::currentThread();//计时QElapsedTimer time;time.start();//快速排序quickSort(list,0,list.size()-1);int milsec = time.elapsed();qDebug() << "快速排序用时：" << milsec << "毫秒";emit finish(list);
}void QuickSort::quickSort(QVector<int> &s, int l, int r)
{if(l<r){int i = l,j = r;int x = s[l];while(i < j){while(i < j && s[j] >= x){j--;}if(i < j){s[i++] = s[j];}while(i < j && s[i] < x){i++;}if(i < j){s[j--] = s[i];}}s[i] = x;quickSort(s,l,i-1);quickSort(s,i+1,r);}
}

 mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H#include <QMainWindow>QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACEclass MainWindow : public QMainWindow
{Q_OBJECTpublic:MainWindow(QWidget *parent = nullptr);~MainWindow();signals:void starting(int num);private:Ui::MainWindow *ui;
};
#endif // MAINWINDOW_H

 mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include<mythread.h>
#include<QThread>
MainWindow::MainWindow(QWidget *parent): QMainWindow(parent), ui(new Ui::MainWindow)
{ui->setupUi(this);//1.创建子线程对象QThread* t1 = new QThread;QThread* t2 = new QThread;QThread* t3 = new QThread;//2.创建任务类的对象Generate* gen = new Generate;BubbleSort* bubble = new BubbleSort;QuickSort* quick = new QuickSort;//3.将任务对象移动到某个子线程中gen->moveToThread(t1);bubble->moveToThread(t2);quick->moveToThread(t3);connect(this,&MainWindow::starting,gen,&Generate::working);//2.启动子线程connect(ui->start,&QPushButton::clicked,this,[=](){emit starting(10000);t1->start();});//随机数子线程发送来的数据触发冒泡排序和快速排序接收数据connect(gen,&Generate::sendArray,bubble,&BubbleSort::working);connect(gen,&Generate::sendArray,quick,&QuickSort::working);//接收子线程发送的数据，显示在randlist里，同时启动两个排序子线程connect(gen,&Generate::sendArray,this,[=](QVector<int> list){//启动两个子线程方法t2->start();t3->start();for (int i=0; i<list.size(); ++i) {ui->randlist->addItem(QString::number(list.at(i)));}});//两个排序子线程处理数据connect(bubble,&BubbleSort::finish,this,[=](QVector<int> list){for (int i=0; i<list.size(); ++i) {ui->bubblelist->addItem(QString::number(list.at(i)));}});connect(quick,&QuickSort::finish,this,[=](QVector<int> list){for (int i=0; i<list.size(); ++i) {ui->quicklist->addItem(QString::number(list.at(i)));}});//资源释放connect(this,&MainWindow::destroyed,this,[=](){//线程释放t1->quit();t1->wait();t1->deleteLater();t2->quit();t2->wait();t2->deleteLater();t3->quit();t3->wait();t3->deleteLater();//任务对象释放gen->deleteLater();bubble->deleteLater();quick->deleteLater();});}MainWindow::~MainWindow()
{delete ui;
}

 main.cpp

#include "mainwindow.h"#include <QApplication>int main(int argc, char *argv[])
{QApplication a(argc, argv);qRegisterMetaType<QVector<int>>("QVector<int>");MainWindow w;w.show();return a.exec();
}

connect函数第五个参数

connect()函数第五个参数为Qt:ConnectionType,用于指定信号和槽的连接类型。同时影响信号的传递方式和槽函数的执行顺序。只有在多线程的时候才意义。

Qt:ConnectionType提供了以下五种方式：

Qt:AutoConnection	在Qt中，会根据信号和槽函数所在的线程自动选择连接类型。如果信号和槽函数在同一线程中，那么使用Qt:DirectConnection类型；如果它们位于不同的线程中，那么使用Qt:QueuedConnection类型。
Qt:DirectConnection	当信号发出时，槽函数会立即在同一线程中执行。这种连接类型适用于信号和槽函数在同一线程中的情况，可以实现直接的函数调用，但需要注意线程安全性。
Qt::QueuedConnection	当信号发出时，槽函数会被插入到接收对象所属的线程的事件队列中，等待下一次事件循环时执行。这种连接类型适用于信号和槽函数在不同线程中的情况，可以确保线程安全。
Qt:BlockingQueuedConnection	与Qt:QueuedConnection类似，但是发送信号的线程会被阻塞，直到槽函数执行完毕，这种连接类型适用于需要等待槽函数执行完毕再继续的场景，但需要注意可能引起线程死锁的风险。
Qt:UniqueConnection	这是一个标志，可以使用位或与上述任何一种连接类型组合使用。