QT多线程的示例

已于 2023-08-13 16:13:04 修改
阅读量923 收藏 9
点赞数 1
分类专栏： QT 文章标签： qt 开发语言
于 2023-07-29 22:27:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48657573/article/details/131927755
版权

想象现在有一个场景，一共有三个线程线程A需要产生1000以内的随机数，线程B需要对这些随机数进行冒泡排序，线程C需要对这些随机数进行快速排序，主线程用来显示线程A的随机数，并且显示线程A和线程B的处理结果，这里我们还可以对比一下快速排序和冒泡排序的速度。
我们设计UI界面如下：
在这里插入图片描述
这个UI界面用到了QListWidget、QPushbutton、QGroupBox控件。
然后我们写三个线程类，把三个线程类都放在MyThread这个文件中，代码如下：

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QThread>
#include <QVector>
#include <QRandomGenerator>
#pragma execution_character_set("utf-8")

class Generate : public QThread
{
    Q_OBJECT
public:
    explicit Generate(QObject *parent = nullptr);

signals:
    void SendArray(QVector<int> num);
public slots:
    void RecviveNum(int num);
protected:
    void run() override;
private:
    int m_num;
};

class MBupple : public QThread
{
    Q_OBJECT
public:
    explicit MBupple(QObject *parent = nullptr);

signals:
    void FinishBupple(QVector<int> flist);
public slots:
    void RecviveNum(QVector<int> rlist);
protected:
    void run() override;
private:
    QVector<int> m_list;
};

class MQuick : public QThread
{
    Q_OBJECT
public:
    explicit MQuick(QObject *parent = nullptr);
signals:
    void FinishQuick(QVector<int> flist);
public slots:
    void RecviveNum(QVector<int> rlist);
protected:
    void run() override;
private:
    QVector<int> m_list;
private:
    void quickSort(QVector<int> &list,int l,int r);
};
#endif // MYTHREAD_H

Generate类用来生成随机数，它有一个槽函数void RecviveNum(int num);这个是用来接收来自主线程发来的随机数的数量，还有一个 void SendArray(QVector num);信号，这个是把生成好的随机数，分别发给主线程显示，和其他两个排序线程排序，void run() override;这个重写基类run函数为了生成随机数，不过这里的随机数并不是真正意义上的随机数，而是伪随机数。
以下是Generate的函数：

Generate::Generate(QObject *parent) : QThread(parent){
}
void Generate::RecviveNum(int num){
    m_num=num;
}
void Generate::run(){
    qDebug()<<"生成随机数的线程ID号为"<<QThread::currentThread();
    QElapsedTimer m_timer;
    m_timer.start();
    QVector<int> randList;
    for(int i=0;i<m_num;i++){
        randList.push_back(qrand()%100000);
    }
    int m_delaytime = m_timer.elapsed();
    qDebug()<<"生成"<<m_num<<"个随机数总共用时:"<<m_delaytime<<"毫秒";
    emit SendArray(randList);
}

MBupple类主要来进行把来自Generate的随机数进行冒泡排序，它的run函数就是冒泡排序，它的FinishBupple函数主要是将排序好的随机数发送给主线程显示，它的RecviveNum函数是拿到来自Generate生成的随机数，以下为实现代码：

MBupple::MBupple(QObject *parent) : QThread(parent{
}
void MBupple::RecviveNum(QVector<int> rlist)
{
    m_list=rlist;
}

void MBupple::run()
{
    qDebug()<<"冒泡排序的线程ID号为"<<QThread::currentThread();
    QElapsedTimer m_timer;
    m_timer.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 m_delaytime = m_timer.elapsed();
    qDebug()<<"冒泡排序随机数总共用时:"<<m_delaytime<<"毫秒";
    emit FinishBupple(m_list);
}

MQuick类和MBupple一样，我这里只给出代码：

MQuick::MQuick(QObject *parent) : QThread(parent)
{

}

void MQuick::RecviveNum(QVector<int> rlist)
{
    m_list=rlist;
}

void MQuick::run()
{
    qDebug()<<"快速排序的线程ID号为"<<QThread::currentThread();
    QElapsedTimer m_timer;
    m_timer.start();
    int temp;
    quickSort(m_list,0,m_list.size()-1);
    int m_delaytime = m_timer.elapsed();
    qDebug()<<"快速排序随机数总共用时:"<<m_delaytime<<"毫秒";
    emit FinishQuick(m_list);
}

void MQuick::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);
    }
}

然后是主线程，主线程主要负责显示生成的随机数以及排序的结果
在这里插入图片描述
这里给出代码：
cpp:

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

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    gen=new Generate;
    mbu=new MBupple;
    mqu=new MQuick;
    connect(this,&Widget::SendNum,gen,&Generate::RecviveNum);
    connect(gen,&Generate::SendArray,this,&Widget::ReceiveArray);
    connect(gen,&Generate::SendArray,mbu,&MBupple::RecviveNum);
    connect(gen,&Generate::SendArray,mqu,&MQuick::RecviveNum);
    connect(mbu,&MBupple::FinishBupple,this,&Widget::ReceiveBuppleArray);
    connect(mqu,&MQuick::FinishQuick,this,&Widget::ReceiveQuickArray);
}

Widget::~Widget()
{
    delete ui;
    if(gen!=nullptr){
        delete gen;
        gen=nullptr;
    }
    if(mbu!=nullptr){
        delete mbu;
        mbu=nullptr;
    }

    if(mqu!=nullptr){
        delete mqu;
        mqu=nullptr;
    }
  
}

void Widget::ReceiveArray(QVector<int> randlist)
{
    m_receivelist=randlist;
    for(int i=0;i<m_receivelist.size();i++){
        ui->Randomlist->addItem(QString::number(m_receivelist.at(i)));
    }
    //启动排序线程
    mbu->start();
    mqu->start();
}

void Widget::ReceiveBuppleArray(QVector<int> randlist)
{
    m_receivelist=randlist;
    for(int i=0;i<m_receivelist.size();i++){
        ui->Bubblelist->addItem(QString::number(m_receivelist.at(i)));
    }
}

void Widget::ReceiveQuickArray(QVector<int> randlist)
{
    m_receivelist=randlist;
    for(int i=0;i<m_receivelist.size();i++){
        ui->Quicklist->addItem(QString::number(m_receivelist.at(i)));
    }
}

void Widget::on_btnstart_clicked()
{
    emit SendNum(10000);
    gen->start();
}

.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QVector>
#include "mythread.h"
#pragma execution_character_set("utf-8")
QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();
signals:
    //向子线程发送生成随机数个数
    void SendNum(int num);
    //发送随机数给冒泡 快速线程
    void SendList(QVector<int> list);
private:
    Ui::Widget *ui;
    QVector<int> m_receivelist;
    Generate* gen=nullptr;
    MBupple* mbu=nullptr;
    MQuick* mqu=nullptr;
public slots:
    //接收子线程随机数
    void ReceiveArray(QVector<int> randlist);

    void ReceiveBuppleArray(QVector<int> randlist);
    void ReceiveQuickArray(QVector<int> randlist);

private slots:
    void on_btnstart_clicked();
};
#endif // WIDGET_H

记得在main.cpp里注册类型，不然传递数据有问题，主要是为了支持信号与槽的机制，方便元对象处理跨线程的数据以及跨dll的数据，保证数据的可靠安全，准确判断数据的类型。

#include "widget.h"

#include <QApplication>

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

这下可以看到三个线程有不同的id号地址，也可以比较出排序的速度
在这里插入图片描述
可能中间这种不停地用信号与槽机制传递数据比较混乱一点，但是仔细捋捋还是能搞懂，另外可以考虑单例模式来实现这种繁琐的数据传递应该更好一点。
另一种线程实现方式：
mythread.h

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QObject>
#include <QVector>
#include <QRandomGenerator>
#include <QThread>
#pragma execution_character_set("utf-8")

class Generate : public QObject
{
    Q_OBJECT
public:
    explicit Generate(QObject *parent = nullptr);

signals:
    void SendArray(QVector<int> num);
public:
    void working(int num);
};

class MBupple : public QObject
{
    Q_OBJECT
public:
    explicit MBupple(QObject *parent = nullptr);

signals:
    void FinishBupple(QVector<int> flist);
public:
    void working(QVector<int> m_list);
};

class MQuick : public QObject
{
    Q_OBJECT
public:
    explicit MQuick(QObject *parent = nullptr);
signals:
    void FinishQuick(QVector<int> flist);
public:
    void working(QVector<int> m_list);
private:
    void quickSort(QVector<int> &list,int l,int r);
};
#endif // MYTHREAD_H

mythread.cpp

#include "mythread.h"
#include <QElapsedTimer>
#include <QDebug>
Generate::Generate(QObject *parent) : QObject(parent)
{

}

void Generate::working(int num){
    qDebug()<<"生成随机数的线程ID号为"<<QThread::currentThread();
    QElapsedTimer m_timer;
    m_timer.start();
    QVector<int> randList;
    for(int i=0;i<num;i++){
        randList.push_back(qrand()%100000);
    }
    int m_delaytime = m_timer.elapsed();
    qDebug()<<"生成"<<num<<"个随机数总共用时:"<<m_delaytime<<"毫秒";
    emit SendArray(randList);
}

MBupple::MBupple(QObject *parent) : QObject(parent)
{

}

void MBupple::working(QVector<int> m_list)
{
    qDebug()<<"冒泡排序的线程ID号为"<<QThread::currentThread();
    QElapsedTimer m_timer;
    m_timer.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 m_delaytime = m_timer.elapsed();
    qDebug()<<"冒泡排序随机数总共用时:"<<m_delaytime<<"毫秒";
    emit FinishBupple(m_list);
}


MQuick::MQuick(QObject *parent) : QObject(parent)
{

}

void MQuick::working(QVector<int> m_list)
{
    qDebug()<<"快速排序的线程ID号为"<<QThread::currentThread();
    QElapsedTimer m_timer;
    m_timer.start();
    int temp;
    quickSort(m_list,0,m_list.size()-1);
    int m_delaytime = m_timer.elapsed();
    qDebug()<<"快速排序随机数总共用时:"<<m_delaytime<<"毫秒";
    emit FinishQuick(m_list);
}

void MQuick::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);
    }
}

widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QVector>
#include "mythread.h"
#include <QThread>


#pragma execution_character_set("utf-8")
QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();
signals:
    //向子线程发送生成随机数个数
    void SendNum(int num);
    //发送随机数给冒泡 快速线程
    void SendList(QVector<int> list);
private:
    Ui::Widget *ui;
    QVector<int> m_receivelist;
    Generate* gen=nullptr;
    MBupple* mbu=nullptr;
    MQuick* mqu=nullptr;
public slots:
    //接收子线程随机数
    void ReceiveArray(QVector<int> randlist);
    void ReceiveBuppleArray(QVector<int> randlist);
    void ReceiveQuickArray(QVector<int> randlist);

private slots:
    void on_btnstart_clicked();
private:
    QThread* t1;
    QThread* t2;
    QThread* t3;

};
#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);
    //线程对象
    t1=new QThread;
    t2=new QThread;
    t3=new QThread;
    //任务对象
    gen=new Generate;
    mbu=new MBupple;
    mqu=new MQuick;
    //任务对象加入线程
    gen->moveToThread(t1);
    mbu->moveToThread(t2);
    mqu->moveToThread(t3);
    connect(this,&Widget::SendNum,gen,&Generate::working);


    connect(gen,&Generate::SendArray,this,&Widget::ReceiveArray);
    connect(gen,&Generate::SendArray,mbu,&MBupple::working);
    connect(gen,&Generate::SendArray,mqu,&MQuick::working);
    connect(mbu,&MBupple::FinishBupple,this,&Widget::ReceiveBuppleArray);
    connect(mqu,&MQuick::FinishQuick,this,&Widget::ReceiveQuickArray);

    connect(this,&Widget::destroy,this,[=]{
        t1->quit();
        t1->wait();
        t1->deleteLater();
        t2->quit();
        t2->wait();
        t2->deleteLater();
        t3->quit();
        t3->wait();
        t3->deleteLater();
        gen->deleteLater();
        mbu->deleteLater();
        mqu->deleteLater();

    });
}

Widget::~Widget()
{
    delete ui;
    if(gen!=nullptr){
        delete gen;
        gen=nullptr;
    }

    if(mbu!=nullptr){
        delete mbu;
        mbu=nullptr;
    }

    if(mqu!=nullptr){
        delete mqu;
        mqu=nullptr;
    }
}

void Widget::ReceiveArray(QVector<int> randlist)
{
    m_receivelist=randlist;
    for(int i=0;i<m_receivelist.size();i++){
        ui->Randomlist->addItem(QString::number(m_receivelist.at(i)));
    }
    //启动排序线程
    t2->start();
    t3->start();
}

void Widget::ReceiveBuppleArray(QVector<int> randlist)
{
    m_receivelist=randlist;
    for(int i=0;i<m_receivelist.size();i++){
        ui->Bubblelist->addItem(QString::number(m_receivelist.at(i)));
    }
}

void Widget::ReceiveQuickArray(QVector<int> randlist)
{
    m_receivelist=randlist;
    for(int i=0;i<m_receivelist.size();i++){
        ui->Quicklist->addItem(QString::number(m_receivelist.at(i)));
    }
}

void Widget::on_btnstart_clicked()
{
    emit SendNum(10000);
    t1->start();
}
昂德森科技
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Qt多线程经典例子
09-19
详细内容，参见博客。http://blog.csdn.net/rl529014/article/details/52815341#comments
5个qt多线程例子
03-25
5个qt多线程例子，关于qt 多线程 TCP UDP socket 仅供参考
Qt编制一个多线程程序
m0_73443478的博客
04-22 250
Qt编制一个多线程程序
【Qt】多线程示例代码（QThread）
最新发布
-凌凌漆-的博客
08-01 171
从QThread继承方式。
QT多线程简单例子
热门推荐
爱拼才会赢
11-08 2万+
在Qt中实现多线程，除了使用全局变量。还可以使用信号/槽机制。 以下例子使用信号/槽机制。 功能： 在主线程A界面上点击按钮，然后对应开起一个线程B。线程B往线程A发送一个字符串，线程A打印出来。 1、工程文件目录 2、thread.h 和thread.cpp #ifndef THREAD_H #define THREAD_H #include&lt;QThread&gt; #in...
Qt多线程实例
studyhardi的博客
05-16 865
以下是单线程的程序，每次程序进到循环里，会出现睡眠假死的操作。 //MyClass.h #ifndef MYCLASS_H #define MYCLASS_H #include <QtWidgets/QWidget> #include <Windows.h> #include "ui_myclass.h" class MyClass : public QWidget { Q_OBJECT public: MyClass(QWidget *parent = 0); ~MyC
qt多线程一个简单的例子
老瓦的笔记本
03-12 726
作者：zgrjkflmkyc 转自：http://blog.csdn.net/zgrjkflmkyc/article/details/9270903 代码如下： [cpp] view plaincopy /**********Main.cpp*************/    #include   #include "MainWindow.h"    int
qt多线程示例
05-25
下面是一个简单的 Qt 多线程示例，它展示了如何在 Qt 中使用多线程来执行耗时的任务，而不会阻塞主线程。 ```cpp #include #include #include class Worker : public QObject { Q_OBJECT public: explicit ...
Qt 多线程及简单实例 demo
03-07
Qt 多线程及简单实例 demo。 多线程的几大特点： 1.多线程的执行顺序无法保证，与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高，因此对...
qt多线程示例继承
05-25
以下是一个简单的示例代码，演示了如何在 Qt 中使用多线程和继承： ```cpp #include class MyThread : public QThread { public: void run() override { // 在这里实现多线程的逻辑 } }; // 在主线程中创建并...
QT多线程实战源代码（QThread）
04-20
QT多线程实战源代码（QThread）是一个关于如何在QT框架中利用多线程进行高效编程的示例集合。QT是一个跨平台的C++库，广泛用于开发GUI应用程序，而QThread是QT提供的一种线程管理机制，使得开发者可以在QT环境中方便...
Qt多线程的一个简单例子
12-02
用QT实现的一个简单多线程例子，可以作为简单的参考历程
12.1 Qt5多线程:多线程及简单实例
02-15
一个Qt5多线程的简单实例，工作线程类WorkThread继承自QThread类。
QT开线程示例
03-09
QT开线程示例 在QT编程中，多线程技术是提高应用程序性能和响应性的重要手段。QT库提供了一套完整的线程支持，使得开发者能够轻松地在Qt应用程序中创建和管理线程。本示例将深入讲解如何在QT中开启线程，并通过实例...
QT多线程编程详解
shenyuan12的专栏
09-09 971
一、线程基础 1、GUI线程与工作线程 每个程序启动后拥有的第一个线程称为主线程，即GUI线程。QT中所有的组件类和几个相关的类只能工作在GUI线程，不能工作在次线程，次线程即工作线程，主要负责处理GUI线程卸下的工作。 2、数据的同步访问 每个线程都有自己的栈，因此每个线程都要自己的调用历史和本地变量。线程共享相同的地址空间。 二、QT多线程简介 QT通过三种形式提供了对线程的支持，分别是平台无关的线程类、线程安全的事件投递、跨线程的信号-槽连接。 QT中线程类包含如下： ...
Qt--多线程的简单实例
zq9955的博客
09-26 1万+
代码部分： threaddig.h #ifndef THREADDIG_H #define THREADDIG_H #include <QDialog> #include "workthread.h" #define MAXSIZE 5 //MAXSIZE宏定义了线程的数目 namespace Ui { class ThreadDig; } class ThreadDig : public QDialog { Q_OBJECT public: explicit Th.
QT多线程简单实例
qq_41979469的博客
04-27 3215
【例】（难度一般） 如图所示，单击“开始”按钮将启动数个工作线程（工作线程数目由MAXSIZE宏决定），各个线程循环打印数字0~9，直到按下“停止”按钮终止所有线程为止. 具体步骤如下。 （1）在头文件“threaddlg.h”中声明用于界面显示所需的控件，其具体代码如下： #include <QDialog> #include <QPushButton&gt...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值