当前位置： 首页 > article >正文

QT创建线程，QT多线程的创建和使用，QT线程池

article 2024/11/15 5:52:20

一·、在Qt中创建多线程的原因和优势

1. **UI响应性：**
   - 在单线程模型中，如果需要执行长时间运行的任务（如网络请求、文件I/O、计算密集型操作等），这将会阻塞主线程，导致UI无响应。通过在单独的线程中执行这些任务，可以确保主线程保持响应性，提高用户体验。

2. **利用多核处理器：**
   - 多线程允许应用程序利用多核处理器的性能优势。通过并行执行任务，可以提高应用程序的性能和效率。

3. **任务分离：**
   - 将不同任务放在不同线程中可以更好地组织和管理代码，提高代码的可读性和维护性。

4. **避免阻塞：**
   - 在GUI应用程序中，使用多线程可以避免阻塞用户界面，保持程序的流畅性和响应性。

5. **并发性：**
   - 通过多线程可以实现并发处理，同时执行多个任务，提高系统的效率。

6. **异步操作：**
   - 多线程使得可以异步执行任务，比如在后台处理数据、下载文件等，在任务完成时通知主线程更新UI。

7. **减少资源冲突：**
   - 通过多线程可以降低资源竞争和冲突，避免因为多个任务同时访问资源而引起的问题。

总的来说，使用多线程可以提高应用程序的性能、响应性和并发处理能力，同时增强程序的可维护性和代码清晰度。在Qt中，通过提供丰富的多线程支持，开发者可以相对容易地实现多线程操作，并充分利用多核处理器的优势。

项目实现效果

二、多线程的创建方法（一）

通过创建多个继承与QThread的类来实现多线程的创建和使用。

本章内容实现三个子线程的创建和使用，分别实现（1）随机数的创建、（2）生成的随机数的快速排序、（3）生成的随机数的冒泡排序。同时将结果显示到主线程界面中。

一、新创建一个Class文件

这里选择QObject，因为QObject是QThread的基类

二、修改myThread的.h文件和.cpp文件

修改结果如下：

三、创建线程类对象

创建三个类对象，方便实现三个线程操作。

四、重写run方法

mythread.h文件如下：

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QThread>
//获取随机数的类对象******************************************
class Random : public QThread
{
    Q_OBJECT
public:
    explicit Random(QObject *parent = nullptr);
protected:
    //重写run方法
    virtual void run();
signals:
    void sendRandom(QVector<int> list);//传递随机数数据的信号
    void sendRandTime(int);//发送耗时
public slots:
    void Random_num_handler(int num_t);//处理主程序传递过来的随机数
private:
    int num;//随机数个数
};

//冒泡排序类对象********************************************
class MaoSort : public QThread
{
    Q_OBJECT
public:
    explicit MaoSort(QObject *parent = nullptr);
protected:
    //重写run方法
    virtual void run();
signals:
    void sendMaoSort(QVector<int> list);//发送排序完成的数列到主程序
    void sendMaoTime(int);//发送耗时
public slots:
    void Random_num_handler(QVector<int> list);//处理主程序传递过来的随机数
private:
    QVector<int> list;//存储传递过来的数列
};

//快速排序类对象*************************************************
class QuickSort : public QThread
{
    Q_OBJECT
public:
    explicit QuickSort(QObject *parent = nullptr);
protected:
    //重写run方法
    virtual void run();
signals:
    void sendQuickSort(QVector<int> list);//发送排序完成的数列到主程序
    void sendQuiTime(int);//发送耗时
public slots:
    void Random_num_handler(QVector<int>);//处理主程序传递过来的随机数
    void quickSort(QVector<int> &list, int low, int high);
private:
    QVector<int> list;//存储传递过来的数列
};

#endif // MYTHREAD_H

mythread.cpp文件如下：

#include "mythread.h"
#include <QVector> //容器
#include <QRandomGenerator> //随机数
#include <QDebug>
#include <QElapsedTimer>
//随机数类对象的构造函数************************************************************
Random::Random(QObject *parent)
    : QThread{parent}
{
    num = 10;//默认获取十个随机数
}
//重写run对象
void Random::run()
{
    QElapsedTimer time;//获取程序执行时间
    time.start();//计时开始
    QRandomGenerator randnum;//初始化随机数对象
    QVector<int> list;//初始化一个int类型的容器，存储生成的随机数

    for(int i = 0; i < num; i++)
    {
        list.push_back(randnum.bounded(10000));//randnum.bounded(200)：生成0-200范围内的随机数，list.push_back:将生成的随机数添加到容器的末尾
    }

    int time_milsec = time.elapsed();//计时结束获取耗时
    emit sendRandom(list);//传递获取的随机数到主程序进行显示
    emit sendRandTime(time_milsec);//发送耗时
    qDebug()<<"获取"<<num<<"个随机数共耗时："<<time_milsec<<"毫秒";
}
//修改随机数个数
void Random::Random_num_handler(int num_t)
{
    num = num_t;
}

//冒泡排序类对象的构造函数************************************************************
MaoSort::MaoSort(QObject *parent)
    : QThread{parent}
{
}
//重写run对象
void MaoSort::run()
{
    QElapsedTimer time;//获取程序执行时间
    time.start();//计时开始
    for(int i = 0; i < list.size(); i++)
    {
        for(int j = 0; j < list.size()-i-1; j++)
        {
            if(list.at(j) >= list.at(j+1))
            {
                int num = list.at(j);
                list.replace(j, list.at(j+1));
                list.replace(j+1, num);
            }
        }
    }
    int time_milsec = time.elapsed();//计时结束获取耗时
    emit sendMaoSort(list);//传递获取的随机数到主程序进行显示
    emit sendMaoTime(time_milsec);//发送耗时
    qDebug()<<"冒泡排序"<<list.size()<<"个随机数共耗时："<<time_milsec<<"毫秒";
}
//存储未排序的数列
void MaoSort::Random_num_handler(QVector<int> list_t)
{
    list = list_t;
}


//快速排序类对象的构造函数***************************************************************
QuickSort::QuickSort(QObject *parent)
    : QThread{parent}
{

}
//重写run对象
void QuickSort::run()
{
    QElapsedTimer time;//获取程序执行时间
    time.start();//计时开始
    quickSort(list, 0, list.size()-1);//进行快排
    int time_milsec = time.elapsed();//计时结束获取耗时
    emit sendQuickSort(list);//传递获取的随机数到主程序进行显示
    emit sendQuiTime(time_milsec);//发送耗时
    qDebug()<<"冒泡排序"<<list.size()<<"个随机数共耗时："<<time_milsec<<"毫秒";
}

void QuickSort::quickSort(QVector<int> &arr, int left, int right)
{
    if(left >= right)
        return;
    else
    {
        int i, j, base, temp;
        i = left, j = right;
        base = arr[left];  //取最左边的数为基准数
        while (i < j)
        {
            while (arr[j] >= base && i < j)
                j--;
            while (arr[i] <= base && i < j)
                i++;
            if(i < j)
            {
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        //基准数归位
        arr[left] = arr[i];
        arr[i] = base;
        quickSort(arr, left, i - 1);//递归左边
        quickSort(arr, i + 1, right);//递归右边
    }
}
//存储未排序的数列
void QuickSort::Random_num_handler(QVector<int> list_t)
{
    list = list_t;
}

五、连接信号与槽

六、项目资料

通过百度网盘分享的文件：mythread_1.rar
链接：https://pan.baidu.com/s/1vcVpocNKAU46xXhFCotN5Q 
提取码：htmm

三、多线程的创建方法（二）

直接使用QObject类，创建多个工作Working，通过将working移动到创建的QThread对象中来实现线程的创建

一、修改文件继承基类为QObject

这里以Random类为例：

二、创建工作working

创建working，这里可使用之前线程的run函数，将run函数替换即可，注意：需要修改函数权限为public权限。

此方法不同于重写run，故而可以直接在working函数中传递参数或者数据，可舍弃方法一中传递的随机数数量、随机数列等参数。

三、创建对应线程并移动任务到相应的线程中

四、连接各部分信号槽

五、书写各个working函数

六、代码

        mythread.h文件如下：

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QObject>
//获取随机数的类对象******************************************
class Random : public QObject
{
    Q_OBJECT
public:
    explicit Random(QObject *parent = nullptr);
    void working(int num);//生成随机数操作的函数
signals:
    void sendRandom(QVector<int> list);//传递随机数数据的信号
    void sendRandTime(int);//发送耗时
};

//冒泡排序类对象********************************************
class MaoSort : public QObject
{
    Q_OBJECT
public:
    explicit MaoSort(QObject *parent = nullptr);

   void working(QVector<int> list);
signals:
    void sendMaoSort(QVector<int> list);//发送排序完成的数列到主程序
    void sendMaoTime(int);//发送耗时
};

//快速排序类对象*************************************************
class QuickSort : public QObject
{
    Q_OBJECT
public:
    explicit QuickSort(QObject *parent = nullptr);

    void working(QVector<int> list);
signals:
    void sendQuickSort(QVector<int> list);//发送排序完成的数列到主程序
    void sendQuiTime(int);//发送耗时
public slots:
    void quickSort(QVector<int> &list, int low, int high);//快排函数
};

#endif // MYTHREAD_H

         mythread.cpp文件如下：

#include "mythread.h"
#include <QVector> //容器
#include <QRandomGenerator> //随机数
#include <QDebug>
#include <QElapsedTimer>
//随机数类对象的构造函数************************************************************
Random::Random(QObject *parent)
    : QObject{parent}
{
}
//重写run对象
void Random::working(int num)
{
    QElapsedTimer time;//获取程序执行时间
    time.start();//计时开始
    QRandomGenerator randnum;//初始化随机数对象
    QVector<int> list;//初始化一个int类型的容器，存储生成的随机数

    for(int i = 0; i < num; i++)
    {
        list.push_back(randnum.bounded(10000));//randnum.bounded(200)：生成0-200范围内的随机数，list.push_back:将生成的随机数添加到容器的末尾
    }

    int time_milsec = time.elapsed();//计时结束获取耗时
    emit sendRandom(list);//传递获取的随机数到主程序进行显示
    emit sendRandTime(time_milsec);//发送耗时
    qDebug()<<"获取"<<num<<"个随机数共耗时："<<time_milsec<<"毫秒";
}

//冒泡排序类对象的构造函数************************************************************
MaoSort::MaoSort(QObject *parent)
    : QObject{parent}
{
}
//重写run对象
void MaoSort::working(QVector<int> list)
{
    QElapsedTimer time;//获取程序执行时间
    time.start();//计时开始
    for(int i = 0; i < list.size(); i++)
    {
        for(int j = 0; j < list.size()-i-1; j++)
        {
            if(list.at(j) >= list.at(j+1))
            {
                int num = list.at(j);
                list.replace(j, list.at(j+1));
                list.replace(j+1, num);
            }
        }
    }
    int time_milsec = time.elapsed();//计时结束获取耗时
    emit sendMaoSort(list);//传递获取的随机数到主程序进行显示
    emit sendMaoTime(time_milsec);//发送耗时
    qDebug()<<"冒泡排序"<<list.size()<<"个随机数共耗时："<<time_milsec<<"毫秒";
}


//快速排序类对象的构造函数***************************************************************
QuickSort::QuickSort(QObject *parent)
    : QObject{parent}
{

}
//重写run对象
void QuickSort::working(QVector<int> list)
{
    QElapsedTimer time;//获取程序执行时间
    time.start();//计时开始
    quickSort(list, 0, list.size()-1);//进行快排
    int time_milsec = time.elapsed();//计时结束获取耗时
    emit sendQuickSort(list);//传递获取的随机数到主程序进行显示
    emit sendQuiTime(time_milsec);//发送耗时
    qDebug()<<"冒泡排序"<<list.size()<<"个随机数共耗时："<<time_milsec<<"毫秒";
}

void QuickSort::quickSort(QVector<int> &arr, int left, int right)
{
    if(left >= right)
        return;
    else
    {
        int i, j, base, temp;
        i = left, j = right;
        base = arr[left];  //取最左边的数为基准数
        while (i < j)
        {
            while (arr[j] >= base && i < j)
                j--;
            while (arr[i] <= base && i < j)
                i++;
            if(i < j)
            {
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        //基准数归位
        arr[left] = arr[i];
        arr[i] = base;
        quickSort(arr, left, i - 1);//递归左边
        quickSort(arr, i + 1, right);//递归右边
    }
}

widget.h文件如下：

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include "mythread.h"
#include <QThread>
QT_BEGIN_NAMESPACE
namespace Ui {
class Widget;
}
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();
signals:
    void Random_num(int);//发送随机数个数信号
public slots:
    void Random_handler(QVector<int>);//处理随机数的槽函数
    void MaoSrot_handler(QVector<int>);//处理冒泡排序完数列的槽函数
    void QuickSrot_handler(QVector<int>);//处理快速排序完数列的槽函数
    //处理每个线程耗时的接收槽函数*********************************************************************
    void RandTime_handler(int);
    void MaoTime_handler(int);
    void QuiTime_handler(int);
private slots:
    void on_pushButton_clicked();

private:
    Ui::Widget *ui;
    //创建子线程对象
    QThread* t1,*t2,*t3;
    //创建任务类对象
    Random * ran;//创建随机数任务指针
    MaoSort* mao;//创建冒泡排序任务指针
    QuickSort* qui;//创建快速排序认为五指针
};
#endif // WIDGET_H

widget.cpp文件如下：

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

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    //1、创建子线程
    t1 = new QThread;
    t2 = new QThread;
    t3 = new QThread;
    //2、创建任务对象
    ran = new Random;//创建随机数线程对象
    mao = new MaoSort;//创建冒泡排序的线程对象
    qui = new QuickSort;//创建快速排序的线程对象
    //3、将任务对象移动到对应的子线程中去,此处分别移动到t1\t2\t3子线程中
    ran->moveToThread(t1);
    mao->moveToThread(t2);
    qui->moveToThread(t3);
    //4、连接参数传递和相应处理函数
    connect(this, &Widget::Random_num, ran, &Random::working);
    connect(ran, &Random::sendRandom, mao, &MaoSort::working);//传递随机数到冒泡排序任务
    connect(ran, &Random::sendRandom, qui, &QuickSort::working);//传递随机数到快排任务
    //5、连接线程执行结果和主线程处理函数
    connect(ran, &Random::sendRandom, this, &Widget::Random_handler);//连接随机数线程发送的随机数和当前界面随机数处理函数
    connect(mao, &MaoSort::sendMaoSort, this, &Widget::MaoSrot_handler);//连接冒泡线程发送的排序好的数列和当前线程排序好的数的处理函数
    connect(qui, &QuickSort::sendQuickSort, this, &Widget::QuickSrot_handler);//连接快速排序线程发送的数列和当前界面排序好的数列的处理函数
    //6、连接耗时传递和接收函数
    connect(ran, &Random::sendRandTime, this, &Widget::RandTime_handler);
    connect(mao, &MaoSort::sendMaoTime, this, &Widget::MaoTime_handler);
    connect(qui, &QuickSort::sendQuiTime, this, &Widget::QuiTime_handler);
}

Widget::~Widget()
{
    delete ui;
}
//点击开始,默认10个随机数开始生成和排序，启动三个线程，可输入随机数个数*****************************************************8
void Widget::on_pushButton_clicked()
{
    if(ui->lineEdit->text().isEmpty())//如果没输入则使用默认随机数100
    {
        emit Random_num(100);
        t1->start();//启动子线程获取随机数
    }
    else
    {
        emit this->Random_num(ui->lineEdit->text().toInt());//获取输入的随机数并发送到线程中
        t1->start();//启动获取随机数的子线程
    }
}
//处理获取的随机数显示到随机数框中*************************************************************
void Widget::Random_handler(QVector<int> list)
{
    for(int i =0; i < list.size(); i++)
    {
        ui->textEdit->append(QString::number(list.at(i)));//将随机数从容器中取出来放入控件中显示
    }
    //开始两个排序线程
    t2->start();//启动冒泡排序线程
    t3->start();//启动快排
}
//处理显示冒泡排序好的数列**************************************************************
void Widget::MaoSrot_handler(QVector<int> list)
{
    for(int i =0; i < list.size(); i++)
    {
        ui->textEdit_mao->append(QString::number(list.at(i)));//将冒泡排序好的数从容器中取出来放入控件中显示
    }
}
//处理显示快速排序好的数列**************************************************************
void Widget::QuickSrot_handler(QVector<int> list)
{
    for(int i =0; i < list.size(); i++)
    {
        ui->textEdit_qui->append(QString::number(list.at(i)));//将冒泡排序好的数从容器中取出来放入控件中显示
    }
}
//处理耗时显示到UI界面**********************************************************************
void Widget::RandTime_handler(int time)
{
    ui->label_random->setText("生成随机数耗时："+QString::number(time)+"ms");
}
void Widget::MaoTime_handler(int time)
{
    ui->label_mao->setText("冒泡排序耗时："+QString::number(time)+"ms");
}
void Widget::QuiTime_handler(int time)
{
    ui->label_qui->setText("快速排序耗时："+QString::number(time)+"ms");
}

七、项目资料

通过百度网盘分享的文件：mythread_2.rar
链接：https://pan.baidu.com/s/1JV4uWC4iYyJu9vXkAOXoJA 
提取码：htmm


http://www.kler.cn/a/319360.html

相关文章：

  • 机器学习在医疗健康领域的应用
  • 使用etl工具kettle的日常踩坑梳理之二、从Hadoop中导出数据
  • jmeter常用配置元件介绍总结之后置处理器
  • Kafka - 启用安全通信和认证机制_SSL + SASL
  • 阿里巴巴通义灵码推出Lingma SWE-GPT：开源模型的性能新标杆
  • Web安全之SQL注入---基础
  • 【华为】用策略路由解决双出口运营商问题
  • Git 工作区、暂存区与修改全解析
  • 网络安全证书考取相关知识
  • 【Linux】环境部署kafka集群
  • 工业一体机在汽车零部件工厂ESOP系统中的关键作用
  • 【记录】在返回值类型为BigDecimal情况下末尾小数位为0的会省略不显示
  • linux如何启用ipv6随机地址
  • QT 中的信号与槽机制详解
  • 2:java的介绍与基础2：Scanner
  • 【BurpSuite】Cross-site scripting (XSS 学徒部分:1-9）
  • JVM面试问题集
  • 航班延误背后隐秘原因--网络安全
  • 41. 如何在MyBatis-Plus中实现批量操作？批量插入和更新的最佳实践是什么？
  • MELON的难题- 华为OD统一考试(E卷)
  • 【Unity服务】如何使用Unity Version Control
  • transformer模型写诗词
  • 【大模型教程】如何在Spring Boot中无缝集成LangChain4j，玩转AI大模型！
  • day-60 字符串中最多数目的子序列
  • 整合SpringSecurity框架经典报错
  • 大数据实验一： Linux系统安装和使用