Qt多线程练习（一）

最新推荐文章于 2023-07-23 22:00:00 发布
最新推荐文章于 2023-07-23 22:00:00 发布
阅读量274 收藏 3
点赞数 3
分类专栏： QT 文章标签： qt c++ 算法 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74396439/article/details/130394135
版权

1.要求

在这里插入图片描述
界面布局如上图所示。

创建 3 个子线程。

点击 开始 按钮后，第一个子线程生成 n n n 个随机数，返回给主线程，主线程再将这个 n n n 个随机数显示出来；

接着，第二个线程，第三个线程分别对生成的 n n n 个随机数做 冒泡排序 和 快速排序，返回给主线程，主线程再将排好序的 n n n 个数显示出来；

快速排序

2.实现效果

在这里插入图片描述
在这里插入图片描述

3.实现

1.第一种方式

分别定义三个线程类，GenerateThread、BubbleSortThread、QuickSortThread，都继承自QThread，再分别重写各自的 run方法。

  • GenerateThread重写 run方法，生成 n n n 个随机数，返回给主线程；
  • BubbleSortThread重写 run方法，将GenerateThread生成 n n n 个随机数进行 冒泡排序，排序之后返回给主线程；
  • QuickSortThread重写 run方法，将GenerateThread生成 n n n 个随机数进行 快速排序，排序之后返回给主线程；

为了方便，三个线程类都定义在同一个文件 mythread.h中。

mythread.h：

#ifndef GENERATETHREAD_H
#define GENERATETHREAD_H

#include <QThread>
#include <QVector>

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

    void run() override;

public slots:
    //接收创建随机数的数量
    void receive_count(int _n);

signals:
    //生成随机数之后，发送信号给主线程
    void sendRandomList(QVector<int> randomList);
private:
    int n;
};

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

    void run() override;

public slots:
    //接收主线程传递过来的 list
    void receive_list(QVector<int> list);

signals:
    //冒泡排序之后，把数据发送给主线程
    void finish(QVector<int> bubbleList);
private:
    QVector<int> _list;
};

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

    void run() override;

public slots:
    //接收主线程传递过来的 list
    void receive_list(QVector<int> list);


signals:
    //快速排序之后，把数据发送给主线程
    void finish(QVector<int> quickList);
private:
    QVector<int> _list;

    //快速排序的方法
    void quick_sort(int l,int r,QVector<int>& nums);
};

#endif // GENERATETHREAD_H

mythread.cpp：

#include "mythread.h"
#include <QVector>
#include <QElapsedTimer>
#include <QDebug>
#include <QTime>

/*****************生成随机数**********************/
GenerateThread::GenerateThread(QObject *parent) : QThread(parent)
{

}

void GenerateThread::receive_count(int _n){
    n = _n;
}

void GenerateThread::run(){
    //加入随机数种子，按时间随机
    qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));

    qDebug()<<"生成随机数线程的地址 "<<QThread::currentThread();
    QElapsedTimer timer;
    timer.start();

    QVector<int> arr(n);
    for(int i = 0;i < n;i++){
        arr[i] = qrand() % 100000;
    }
    qDebug()<<"生成 "<<n<<" 个随机数总共消耗的时间 : "<<timer.elapsed()<<"ms";
    emit sendRandomList(arr);
}

/*****************生成随机数**********************/


/*****************冒泡排序**********************/
BubbleSortThread::BubbleSortThread(QObject *parent) : QThread(parent)
{

}

void BubbleSortThread::receive_list(QVector<int> list){
    _list = list;
}

void BubbleSortThread::run(){

    qDebug()<<"冒泡排序线程的地址 "<<QThread::currentThread();
    QElapsedTimer timer;
    timer.start();

    int n = _list.size();

    //冒泡排序
    for(int i = 0;i < n;i++){
        for(int j = i + 1;j < n;j++){
            if(_list[i] > _list[j]){
                int temp = _list[i];
                _list[i] = _list[j];
                _list[j] = temp;
            }
        }
    }

    qDebug()<<"冒泡排序消耗的时间为 : "<<timer.elapsed()<<"ms";
    emit finish(_list);
}

/*****************冒泡排序**********************/


/*****************快速排序**********************/

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

}

void QuickSortThread::receive_list(QVector<int> list){
    _list = list;
}

//快速排序
void QuickSortThread::quick_sort(int l,int r,QVector<int>& nums){
    //只有一个元素，就直接返回
    if(l >= r) return;

    qSwap(nums[l] , nums[l + qrand() % (r - l + 1) ]);

    int x = nums[l];
    int i = l , j = r;
    while(i < j){
        while(i < j && nums[j] > x) j--;
        if(i < j) nums[i++] = nums[j];
        while(i < j && nums[i] < x) i++;
        if(i < j) nums[j--] = nums[i];
    }
    nums[i] = x;
    quick_sort(l , i - 1 , nums);
    quick_sort(i + 1 , r , nums);
}

void QuickSortThread::run(){

    qDebug()<<"快速排序线程的地址 "<<QThread::currentThread();
    QElapsedTimer timer;
    timer.start();

    int n = _list.size();

    //快速排序
    quick_sort(0 , n - 1 , _list);

    qDebug()<<"快速排序消耗的时间为 : "<<timer.elapsed()<<"ms";
    emit finish(_list);
}

/*****************快速排序**********************/

mainwindow.h：

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>


QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

signals:
    //发送信号给子线程，指定生成 _n 个随机数
    void start_generate_random(int _n);


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);

    GenerateThread * generateThread = new GenerateThread();

    BubbleSortThread * bubbleSortThread = new BubbleSortThread();

    QuickSortThread * quickSortThread = new QuickSortThread();

    //点击按钮，把指定生成随机数个数的信号发给子线程 ; 再启动子线程生成随机数

    connect(this,&MainWindow::start_generate_random,generateThread,&GenerateThread::receive_count);

    connect(ui->startBtn,&QPushButton::clicked,this,[=](){
        //生成 10000 个随机数
        emit start_generate_random(10000);

        //启动生成随机数的子线程
        generateThread->start();
    });

    //将随机数生成线程产生的数据，发送到另外两个排序子线程
    connect(generateThread,&GenerateThread::sendRandomList,bubbleSortThread,&BubbleSortThread::receive_list);
    connect(generateThread,&GenerateThread::sendRandomList,quickSortThread,&QuickSortThread::receive_list);

    //子线程生成随机数之后，会发送信号给主线程，主线程再将生成的随机数显示到控件中
    connect(generateThread,&GenerateThread::sendRandomList,this,[=](QVector<int> list){

        //启动两个排序子线程
        bubbleSortThread->start();
        quickSortThread->start();

        //把生成的随机数都添加到randomList中，让它显示出来
        for(int i = 0;i < list.size();i++){
            ui->randomList->addItem(QString::number(list.at(i)));
        }
    });

    //冒泡排序结束后，将排好序的数据发送到主线程，主线程将其显示到控件中
    connect(bubbleSortThread,&BubbleSortThread::finish,this,[=](QVector<int> list){
        for(int i = 0;i < list.size();i++){
            ui->bubbleList->addItem(QString::number(list.at(i)));
        }
    });

    //快速排序结束后，将排好序的数据发送到主线程，主线程将其显示到控件中
    connect(quickSortThread,&QuickSortThread::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,[=](){
        generateThread->quit();
        generateThread->wait();
        generateThread->deleteLater();

        bubbleSortThread->quit();
        bubbleSortThread->wait();
        bubbleSortThread->deleteLater();

        quickSortThread->quit();
        quickSortThread->wait();
        quickSortThread->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();
}

2.第二种方式

分别定义三个 任务类（注意：此时已经不是线程类），GenerateThread、BubbleSortThread、QuickSortThread，都继承自QObject，再分别定义实现各自的 work(不一定是 work，名字随意定义)方法。

  • GenerateThread实现work方法，生成 n n n 个随机数，返回给主线程；
  • BubbleSortThread实现work方法，将GenerateThread生成 n n n 个随机数进行 冒泡排序，排序之后返回给主线程；
  • QuickSortThread实现 work方法，将GenerateThread生成 n n n 个随机数进行 快速排序，排序之后返回给主线程；

新建三个线程对象 t1 , t2 , t3。把GenerateThread、BubbleSortThread、QuickSortThread任务对象分别移动到 三个线程t1 , t2 , t3中，按照流程启动线程。

mythread.h：

#ifndef GENERATETHREAD_H
#define GENERATETHREAD_H

#include <QObject>
#include <QVector>

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

    void work(int n);
signals:
    //生成随机数之后，发送信号给主线程
    void sendRandomList(QVector<int> randomList);
};

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

    void work(QVector<int> list);
signals:
    //冒泡排序之后，把数据发送给主线程
    void finish(QVector<int> bubbleList);
};

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

    void work(QVector<int> list);

signals:
    //快速排序之后，把数据发送给主线程
    void finish(QVector<int> quickList);
private:
    //快速排序的方法
    void quick_sort(int l,int r,QVector<int>& nums);
};

#endif // GENERATETHREAD_H

mythread.cpp：

#include "mythread.h"
#include <QVector>
#include <QElapsedTimer>
#include <QDebug>
#include <QTime>
#include <QThread>

/*****************生成随机数**********************/
GenerateThread::GenerateThread(QObject *parent) : QObject(parent)
{

}


void GenerateThread::work(int n){
    //加入随机数种子，按时间随机
    qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));

    qDebug()<<"生成随机数线程的地址 "<<QThread::currentThread();
    QElapsedTimer timer;
    timer.start();

    QVector<int> arr(n);
    for(int i = 0;i < n;i++){
        arr[i] = qrand() % 100000;
    }
    qDebug()<<"生成 "<<n<<" 个随机数总共消耗的时间 : "<<timer.elapsed()<<"ms";
    emit sendRandomList(arr);
}

/*****************生成随机数**********************/


/*****************冒泡排序**********************/
BubbleSortThread::BubbleSortThread(QObject *parent) : QObject(parent)
{

}

void BubbleSortThread::work(QVector<int> list){

    qDebug()<<"冒泡排序线程的地址 "<<QThread::currentThread();
    QElapsedTimer timer;
    timer.start();

    int n = list.size();

    //冒泡排序
    for(int i = 0;i < n;i++){
        for(int j = i + 1;j < n;j++){
            if(list[i] > list[j]){
                int temp = list[i];
                list[i] = list[j];
                list[j] = temp;
            }
        }
    }

    qDebug()<<"冒泡排序消耗的时间为 : "<<timer.elapsed()<<"ms";
    emit finish(list);
}

/*****************冒泡排序**********************/


/*****************快速排序**********************/

QuickSortThread::QuickSortThread(QObject *parent) : QObject(parent)
{

}

//快速排序
void QuickSortThread::quick_sort(int l,int r,QVector<int>& nums){
    //只有一个元素，就直接返回
    if(l >= r) return;

    qSwap(nums[l] , nums[l + qrand() % (r - l + 1) ]);

    int x = nums[l];
    int i = l , j = r;
    while(i < j){
        while(i < j && nums[j] > x) j--;
        if(i < j) nums[i++] = nums[j];
        while(i < j && nums[i] < x) i++;
        if(i < j) nums[j--] = nums[i];
    }
    nums[i] = x;
    quick_sort(l , i - 1 , nums);
    quick_sort(i + 1 , r , nums);
}

void QuickSortThread::work(QVector<int> list){

    qDebug()<<"快速排序线程的地址 "<<QThread::currentThread();
    QElapsedTimer timer;
    timer.start();

    int n = list.size();

    //快速排序
    quick_sort(0 , n - 1 , list);

    qDebug()<<"快速排序消耗的时间为 : "<<timer.elapsed()<<"ms";
    emit finish(list);
}

/*****************快速排序**********************/

mainwindow.h：

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>


QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

signals:
    //发送信号给子线程，指定生成 _n 个随机数
    void start_generate_random(int _n);


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.新建任务对象
    GenerateThread * generateThread = new GenerateThread();

    BubbleSortThread * bubbleSortThread = new BubbleSortThread();

    QuickSortThread * quickSortThread = new QuickSortThread();

    //2.新建三个线程
    QThread * t1 = new QThread();
    QThread * t2 = new QThread();
    QThread * t3 = new QThread();

    //3.把任务对象移到子线程中
    generateThread->moveToThread(t1);
    bubbleSortThread->moveToThread(t2);
    quickSortThread->moveToThread(t3);

    //点击按钮，把指定生成随机数个数的信号发给子线程 ; 再启动子线程生成随机数

    connect(this,&MainWindow::start_generate_random,generateThread,&GenerateThread::work);

    connect(ui->startBtn,&QPushButton::clicked,this,[=](){
        //生成 10000 个随机数
        emit start_generate_random(10000);

        //启动生成随机数的子线程
        t1->start();
    });

    //将随机数生成线程产生的数据，发送到另外两个排序子线程
    connect(generateThread,&GenerateThread::sendRandomList,bubbleSortThread,&BubbleSortThread::work);
    connect(generateThread,&GenerateThread::sendRandomList,quickSortThread,&QuickSortThread::work);

    //子线程生成随机数之后，会发送信号给主线程，主线程再将生成的随机数显示到控件中
    connect(generateThread,&GenerateThread::sendRandomList,this,[=](QVector<int> list){

        //启动两个排序子线程
        t2->start();
        t3->start();

        //把生成的随机数都添加到randomList中，让它显示出来
        for(int i = 0;i < list.size();i++){
            ui->randomList->addItem(QString::number(list.at(i)));
        }
    });

    //冒泡排序结束后，将排好序的数据发送到主线程，主线程将其显示到控件中
    connect(bubbleSortThread,&BubbleSortThread::finish,this,[=](QVector<int> list){
        for(int i = 0;i < list.size();i++){
            ui->bubbleList->addItem(QString::number(list.at(i)));
        }
    });

    //快速排序结束后，将排好序的数据发送到主线程，主线程将其显示到控件中
    connect(quickSortThread,&QuickSortThread::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();

        generateThread->deleteLater();

        bubbleSortThread->deleteLater();

        quickSortThread->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();
}

3.第三种方式

使用 Qt 内置的线程池对象 QThreadPool。

分别定义三个 任务类（注意：此时已经不是线程类），GenerateThread、BubbleSortThread、QuickSortThread，都继承自QObject和 QRunnable，再分别重写各自的 run方法。

  • GenerateThread重写run方法，生成 n n n 个随机数，返回给主线程；
  • BubbleSortThread重写run方法，将GenerateThread生成 n n n 个随机数进行 冒泡排序，排序之后返回给主线程；
  • QuickSortThread重写 run方法，将GenerateThread生成 n n n 个随机数进行 快速排序，排序之后返回给主线程；

使用线程池的静态方法 QThreadPool::globalInstance()->start(任务对象)，把GenerateThread、BubbleSortThread、QuickSortThread任务对象分别扔到线程池中执行任务。

mythread.h：

#ifndef GENERATETHREAD_H
#define GENERATETHREAD_H

#include <QRunnable>
#include <QObject>
#include <QVector>

class GenerateThread : public QObject , public QRunnable
{
    Q_OBJECT
public:
    explicit GenerateThread(QObject *parent = nullptr);

    void run() override;

public slots:
    //接收创建随机数的数量
    void receive_count(int _n);

signals:
    //生成随机数之后，发送信号给主线程
    void sendRandomList(QVector<int> randomList);
private:
    int n;
};

class BubbleSortThread : public QObject , public QRunnable
{
    Q_OBJECT
public:
    explicit BubbleSortThread(QObject *parent = nullptr);

    void run() override;

public slots:
    //接收主线程传递过来的 list
    void receive_list(QVector<int> list);

signals:
    //冒泡排序之后，把数据发送给主线程
    void finish(QVector<int> bubbleList);
private:
    QVector<int> _list;
};

class QuickSortThread : public QObject , public QRunnable
{
    Q_OBJECT
public:
    explicit QuickSortThread(QObject *parent = nullptr);

    void run() override;

public slots:
    //接收主线程传递过来的 list
    void receive_list(QVector<int> list);


signals:
    //快速排序之后，把数据发送给主线程
    void finish(QVector<int> quickList);
private:
    QVector<int> _list;

    //快速排序的方法
    void quick_sort(int l,int r,QVector<int>& nums);
};

#endif // GENERATETHREAD_H

mythread.cpp：

#include "mythread.h"
#include <QVector>
#include <QElapsedTimer>
#include <QDebug>
#include <QThread>
#include <QTime>

/*****************生成随机数**********************/
GenerateThread::GenerateThread(QObject *parent) : QObject(parent),QRunnable()
{
    //设置任务事件执行结束之后自动析构
    setAutoDelete(true);
}

void GenerateThread::receive_count(int _n){
    n = _n;
}

void GenerateThread::run(){
    //加入随机数种子，按时间随机
    qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));

    qDebug()<<"生成随机数线程的地址 "<<QThread::currentThread();
    QElapsedTimer timer;
    timer.start();

    QVector<int> arr(n);
    for(int i = 0;i < n;i++){
        arr[i] = qrand() % 100000;
    }
    qDebug()<<"生成 "<<n<<" 个随机数总共消耗的时间 : "<<timer.elapsed()<<"ms";
    emit sendRandomList(arr);
}

/*****************生成随机数**********************/


/*****************冒泡排序**********************/
BubbleSortThread::BubbleSortThread(QObject *parent) : QObject(parent),QRunnable()
{
    //设置任务事件执行结束之后自动析构
    setAutoDelete(true);
}

void BubbleSortThread::receive_list(QVector<int> list){
    _list = list;
}

void BubbleSortThread::run(){

    qDebug()<<"冒泡排序线程的地址 "<<QThread::currentThread();
    QElapsedTimer timer;
    timer.start();

    int n = _list.size();

    //冒泡排序
    for(int i = 0;i < n;i++){
        for(int j = i + 1;j < n;j++){
            if(_list[i] > _list[j]){
                int temp = _list[i];
                _list[i] = _list[j];
                _list[j] = temp;
            }
        }
    }

    qDebug()<<"冒泡排序消耗的时间为 : "<<timer.elapsed()<<"ms";
    emit finish(_list);
}

/*****************冒泡排序**********************/


/*****************快速排序**********************/

QuickSortThread::QuickSortThread(QObject *parent) : QObject(parent),QRunnable()
{
    //设置任务事件执行结束之后自动析构
    setAutoDelete(true);
}

void QuickSortThread::receive_list(QVector<int> list){
    _list = list;
}

//快速排序
void QuickSortThread::quick_sort(int l,int r,QVector<int>& nums){
    //只有一个元素，就直接返回
    if(l >= r) return;

    qSwap(nums[l] , nums[l + qrand() % (r - l + 1) ]);

    int x = nums[l];
    int i = l , j = r;
    while(i < j){
        while(i < j && nums[j] > x) j--;
        if(i < j) nums[i++] = nums[j];
        while(i < j && nums[i] < x) i++;
        if(i < j) nums[j--] = nums[i];
    }
    nums[i] = x;
    quick_sort(l , i - 1 , nums);
    quick_sort(i + 1 , r , nums);
}

void QuickSortThread::run(){

    qDebug()<<"快速排序线程的地址 "<<QThread::currentThread();
    QElapsedTimer timer;
    timer.start();

    int n = _list.size();

    //快速排序
    quick_sort(0 , n - 1 , _list);

    qDebug()<<"快速排序消耗的时间为 : "<<timer.elapsed()<<"ms";
    emit finish(_list);
}

/*****************快速排序**********************/

mainwindow.h：

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>


QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

signals:
    //发送信号给子线程，指定生成 _n 个随机数
    void start_generate_random(int _n);


private:
    Ui::MainWindow *ui;
};
#endif // MAINWINDOW_H

mainwindow.cpp：

#include "mainwindow.h"
#include "ui_mainwindow.h"

#include "mythread.h"

#include <QThreadPool>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    //1.新建任务对象
    GenerateThread * generateThread = new GenerateThread();

    BubbleSortThread * bubbleSortThread = new BubbleSortThread();

    QuickSortThread * quickSortThread = new QuickSortThread();

    //2.把任务对象扔到 线程池 中开始执行即可

    //点击按钮，把指定生成随机数个数的信号发给子线程 ; 再启动子线程生成随机数

    connect(this,&MainWindow::start_generate_random,generateThread,&GenerateThread::receive_count);

    connect(ui->startBtn,&QPushButton::clicked,this,[=](){
        //生成 10000 个随机数
        emit start_generate_random(10000);

        //把生成随机数的任务对象扔到 线程池 中执行
        QThreadPool::globalInstance()->start(generateThread);
    });

    //将随机数生成线程产生的数据，发送到另外两个排序子线程
    connect(generateThread,&GenerateThread::sendRandomList,bubbleSortThread,&BubbleSortThread::receive_list);
    connect(generateThread,&GenerateThread::sendRandomList,quickSortThread,&QuickSortThread::receive_list);

    //子线程生成随机数之后，会发送信号给主线程，主线程再将生成的随机数显示到控件中
    connect(generateThread,&GenerateThread::sendRandomList,this,[=](QVector<int> list){

        //把 两个排序的任务对象 扔到 线程池 中执行
        QThreadPool::globalInstance()->start(bubbleSortThread);
        QThreadPool::globalInstance()->start(quickSortThread);

        //把生成的随机数都添加到randomList中，让它显示出来
        for(int i = 0;i < list.size();i++){
            ui->randomList->addItem(QString::number(list.at(i)));
        }
    });

    //冒泡排序结束后，将排好序的数据发送到主线程，主线程将其显示到控件中
    connect(bubbleSortThread,&BubbleSortThread::finish,this,[=](QVector<int> list){
        for(int i = 0;i < list.size();i++){
            ui->bubbleList->addItem(QString::number(list.at(i)));
        }
    });

    //快速排序结束后，将排好序的数据发送到主线程，主线程将其显示到控件中
    connect(quickSortThread,&QuickSortThread::finish,this,[=](QVector<int> list){
        for(int i = 0;i < list.size();i++){
            ui->quickList->addItem(QString::number(list.at(i)));
        }
    });

    //线程池会自动释放资源，我们不需要管理
}

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();
}

4.建议

推荐使用第二种方式 或者 第三种线程池的方式。

  • 第二种方式相比于第一种，精简了很多代码；
  • 第三种方式使用线程池来管理线程，效率更高，而且我们不用管理资源释放；

参考视频

感觉画质不如…原神
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
qt多线程显示图片.rar
03-07
qt两个线程同时访问图片，是对QThread的一个小练习。将文件名改为英文后再编译执行
QT/C++多线程练习:单生产者多消费者(巨详细版本)
dddaZZ的博客
09-09 1251
基于linux qt/c++的关于线程的练习涉及线程的创建和退出、多线程的基本管理、定时器的使用、QList存储线程指针等操作。都是基础知识，适合新手练习。
Qt 的4种多线程实现详解 （** 含测试代码）
ken2232的博客
07-23 430
Qt 的4种多线程实现详解
QT每日一练day29：QT中的多线程探究
小勇博客
05-11 250
一.未使用多线程，则w0先运行完后，w1才开始运行 运行结果(GIF动图)： main.cpp xiaowen_QT_day29.pro QT+=widgets SOURCES += \ main.cpp main.cpp #include<QApplication> #include<QDebug> #include<QThread> class Work { public: Work(const QString& name):_obje.
QT多线程编程详解
shenyuan12的专栏
09-09 790
一、线程基础 1、GUI线程与工作线程 每个程序启动后拥有的第一个线程称为主线程，即GUI线程。QT中所有的组件类和几个相关的类只能工作在GUI线程，不能工作在次线程，次线程即工作线程，主要负责处理GUI线程卸下的工作。 2、数据的同步访问 每个线程都有自己的栈，因此每个线程都要自己的调用历史和本地变量。线程共享相同的地址空间。 二、QT多线程简介 QT通过三种形式提供了对线程的支持，分别是平台无关的线程类、线程安全的事件投递、跨线程的信号-槽连接。 QT中线程类包含如下： ...
QThread用法学习及多线程同步(一)
styyzxjq2009的专栏
11-28 5546
非常好的博文：Qt 线程基础(QThread、QtConcurrent等) http://blog.csdn.net/dbzhang800/article/details/6554104 QThread 是用来管理线程的，它所处的线程和它管理的线程并不是同一个东西 QThread 所处的线程，就是执行 QThread t(0) 或 QThread * t=new QThread(0)
QThread的多线程用法
zw_ggr_2017的博客
05-13 863
QThread
Qt多线程TCP网络验证程序
06-15
前一阵子正好不忙，然后为了熟练Qt的TCP协议，就在空闲时间写了这么个练习程序，如果也有想要熟悉Qt的TCP协议的朋友，还是有看一看做一做对比的价值的，不过呢写着写着发现单纯的网络验证可能还是用http好一点，所以...
QT/C++多线程练习:单生产者多消费者(源码)
09-09
涉及 线程创建与退出、线程暂停、父子线程之前以及兄弟线程之间的参数和信号传递、多线程的以及多线程的管理。要求是练习的demo对于以上的点只要涉及基础即可。 主线程、生产者线程（一）、消费者管理线程（一）、...
第12章Qt5多线程
04-12
本书以Qt 5作为平台，每个章节在简单介绍开发环境的基础上，用一个小实例，介绍Qt 5应用程序开发各个方面，然后系统介绍Qt 5应用程序的开发技术，一般均通过实例介绍和讲解内容。最后通过三个大实例，系统介绍Qt 5...
适合初学者的QT多线程操作的例子
06-16
适合初学者的QT多线程操作的例子 适合初学者的QT多线程操作的例子
指纹识别算法练习，基于FVC2004数据库，Qt平台开发，核心C语言实现.zip
最新发布
04-22
Qt Linguist工具支持应用程序的多语言翻译和本地化工作，确保软件能适应全球市场。 开发工具与生态系统： Qt Creator是一款集成开发环境（IDE），集成了项目管理、代码编辑、调试、版本控制、QML预览等多种功能...
QT下的QThread多线程
ljjjjjjjjjjj的博客
11-21 747
多线程可以使用的场景：如果有多个独立的功能，需要并行处理，此时为了提高cpu利用率，从而节省时间，可以采用多线程去实现。原理是把一个串行执行的任务，改变为多个并行任务，减少cpu的等待时间，例如同时读取写多个文件，并处理文件中的数据。使用时需要实例化一个QThread，然后把自己创建的类移动到这个QThread里面，最后需要执行自己创建的类里的方法，让线程运行起来。qt下多线程有2种方案，一种是派生QThread类，另一种是派生QObject。
QT中的线程
weixin_49606782的博客
09-23 2631
主线程(又称 GUI线程),负责监控窗口上的任何事件,一旦发现事件,立马处理.GUI线程只负责 UI刷新.但是有时候,任务很耗时,GUI进程会卡住,UI无响应这个时候创建一个新的子线程,负责处理 耗时的任务,注意：非GUI线程禁止访问 界面上任何元素.
Qt下的多线程的使用
Blunt_Du的博客
08-21 1390
Qt中关于多线程的类为QThread，有三种使用方法：一种方法是通过一个类继承QThread类，同时重写Thread::run()函数；第二种是直接实例化一个QThread，之后将继承自QObject的对象，通过QOjbect::moveToThread()搬到之前实例化的QThread执行；最后一种是通过直接将一个函数搬到QThread中执行，有点类似于pthread_create()的方式。
QT的多线程详解(包含案例)
Lancer7662的博客
06-07 5837
#QT实现多线程(重写RUN函数的方法)
【QT专栏】QT中实现多线程的四种方式和线程同步
热门推荐
weixin_43729127的博客
02-18 1万+
详细的介绍了在Qt中多线程使用和线程同步的概念，也可以参考Qt的开发文档并且介绍的及其细微入至！！！
Qt——线程类QThread
weixin_30393907的博客
02-09 277
本文主要介绍Qt中线程类QThread的用法，参考（翻译+修改）了一篇文章：PyQt: Threading Basics Tutorial，虽然使用的是PyQt，但与C++中Qt的用法大同小异，不必太在意语言的差异。 在这篇文章中，我将写一个获取热点新闻的程序（使用新闻网站reddit.com的api），每隔2秒发送一个关键字，从服务器获得与该关键字相关的一条热点新闻。 我们的目标是实现以下几...
【Qt】Qt多线程开发—实现多线程设计的四种方法
iriczhao的博客
02-14 1万+
Qt—使用Qt实现多线程设计的四种方法 一、写在前面 ​ 这篇文章内容是：关于Qt多线程应用设计，在Qt中提供了四种方法来进行多线程编程和设计。合理的选择对应的方法来解决实际开发中遇到的开发问题有助于对应用程序进行更合理设计。 文章目录Qt—使用Qt实现多线程设计的四种方法一、写在前面二、【方法一】 QThread：带有可选事件循环的底层API三、【方法二】 QThreadPool和QRunnable：重用线程四、【方法三 】Qt并发：使用高级API五、【方法四】 WorkerScript：QML中的线程化
写一个qt 多线程 usb cdc 代码
05-28
以下是一个简单的Qt多线程USB CDC代码示例，用于从USB串口读取数据并显示到界面上： ```cpp // main.cpp #include #include "USBThread.h" int main(int argc, char *argv[]) { QCoreApplication a(argc, argv);...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值