QT多线程

Stephen-Chen

已于 2022-02-26 20:48:38 修改

阅读量821

点赞数 2

分类专栏： QT 文章标签： qt 开发语言 c++

于 2022-02-26 20:41:58 首次发布

本文链接：https://blog.csdn.net/ADAS_CHEN/article/details/123154774

版权

QT 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

引言：设应用程序在某些情况下需要处理比较复杂的逻辑，如果只有一个线程去处理，就会导致窗口卡顿，无法处理用户的相关操作。这种情况下就需要使用多线程，其中一个线程处理窗口事件，其他线程进行逻辑运算，多个线程各司其职，不仅可以提高用户体验还可以提升程序的执行效率。本文主要介绍用worker类通过moveToThread移动进入新线程。对于重写父类的 run () 方法，在该函数内部编写子线程要处理的具体的业务流程的方法现在很少用之，所以不做过多介绍。

需要注意的事项：

默认的线程在Qt中称之为窗口线程，也叫主线程，负责窗口事件处理或者窗口控件数据的更新
子线程负责后台的业务逻辑处理，子线程中不能对窗口对象做任何操作，这些事情需要交给窗口线程处理
主线程和子线程之间如果要进行数据的传递，需要使用Qt中的信号槽机制，所有需要继承QObject的类

1.线程类QThread的函数

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

1.2信号和槽函数

信号

// 线程中执行的任务完成了, 发出该信号
// 任务函数中的处理逻辑执行完毕了
[signal] void QThread::finished();
// 开始工作之前发出这个信号, 一般不使用
[signal] void QThread::started();

槽

// 线程中执行的任务完成了, 发出该信号
// 任务函数中的处理逻辑执行完毕了
[signal] void QThread::finished();
// 开始工作之前发出这个信号, 一般不使用
[signal] void QThread::started();

1.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);	// 单位: 微秒

1.4任务处理函数

// 子线程要处理什么任务, 需要写到 run() 中
[virtual protected] void QThread::run();

这个 run() 是一个虚函数，如果想让创建的子线程执行某个任务，需要写一个子类让其继承 QThread，并且在子类中重写父类的 run() 方法，函数体就是对应的任务处理流程。另外，这个函数是一个受保护的成员函数，不能够在类的外部调用，如果想要让线程执行这个函数中的业务流程，需要通过当前线程对象调用槽函数 start() 启动子线程，当子线程被启动，这个 run() 函数也就在线程内部被调用了。

void run() override;

2.具体列子多线程运用冒泡排序和快速排序

注意事项：

创建工作类mythread中子类必须继承QObject
每个工作类中都要有void working(QVector<int> list);

2.1 在mythread中创建三个子类：生成，冒泡，快速

Generate ：用于生成10000个随机数

head中

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

    void working(int num);

signals:
   void sendArray(QVector<int> num);

public slots:

};

cpp中

Generate::Generate(QObject *parent) :QObject(parent) //构造函数都继承QObject
{

}

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()%10000);
    }
    int milsec = time.elapsed();  //记录总共时间
    qDebug() <<"生成"<<num<<"个随机数所用的时间："<<milsec<<"毫秒";
    emit sendArray(list);
}

BubbleSort类：用于排序10000个随机数

head中


class BubbleSort : public QObject
{
    Q_OBJECT
public:
    explicit BubbleSort(QObject *parent = nullptr);
    void working(QVector<int> list);

signals:
   void finish(QVector<int> num);

public slots:

};

cpp中

BubbleSort::BubbleSort(QObject *parent): QObject(parent)
{

}

void BubbleSort::working(QVector<int> list)
{
    qDebug()<<"冒泡排序的的线程的线程地址为："<<QThread::currentThread();
//    QVector<int> list ;  //容器 将生成数放在容器之中
    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类：用于排序10000个随机数

head中

class QuickSort : public QObject
{
    Q_OBJECT
public:
    explicit QuickSort(QObject *parent = nullptr);
    void  working(QVector<int> list); 

private:
    QVector<int> m_list;
   void quickSort(QVector<int> &list,int l ,int r);

signals:
   void finish(QVector<int> num);

public slots:

};

cpp中


QuickSort::QuickSort(QObject *parent): QObject(parent)
{

}

void QuickSort::working(QVector<int> list)
{
    qDebug()<<"快速排序的的线程的线程地址为："<<QThread::currentThread();
//    QVector<int> list ;  //容器 将生成数放在容器之中
    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;
        // 拿出第一个元素, 保存到x中,第一个位置成为一个坑
        int x = s[l];
        while (i < j)
        {
            // 从右向左找小于x的数
            while (i < j && s[j] >= x)
            {
                //左移, 直到遇到小于等于x的数
                j--;
            }
            if (i < j)
            {
                //将右侧找到的小于x的元素放入左侧坑中, 右侧出现一个坑
                //左侧元素索引后移
                s[i++] = s[j];
            }

            // 从左向右找大于等于x的数
            while (i < j && s[i] < x)
            {
                //右移, 直到遇到大于x的数
                i++;
            }
            if (i < j)
            {
                //将左侧找到的元素放入右侧坑中, 左侧出现一个坑
                //右侧元素索引向前移动
                s[j--] = s[i];
            }
        }
        //此时 i=j,将保存在x中的数填入坑中
        s[i] = x;
        quickSort(s, l, i - 1); // 递归调用
        quickSort(s, i + 1, r);
    }
}

2.2 mainwindow中实现线程调用

head文件：构建信号void starting(int num);

#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:
    void starting(int num);

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

cpp中

创建子线程的对象
创建任务类的对象
将任务对象移动到某子线程中

  //按照线性方式
    //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);
    //启动gen子线程线程
    connect(ui->start,&QPushButton::clicked,this,[=](){
        emit starting(10000);
        t1->start();
    });
   //gen子线程将生成的随机数组发送到，bubble中的working函数
    connect(gen,&Generate::sendArray,bubble,&BubbleSort::working);
    //gen子线程将生成的随机数组发送到，quick中的working函数
    connect(gen,&Generate::sendArray,quick,&QuickSort::working);
    
    connect(gen,&Generate::sendArray,this,[=](QVector<int>list){
        t2->start(); //启动bubble子线程
        t3->start();

        for(int i=0;i<list.size();i++)
        {
            ui->randList->addItem(QString::number(list.at(i)));
        }
    });

    
    //将bubble的finish的床给加入图框中
    connect(bubble,&BubbleSort::finish,this,[=](QVector<int>list){

        for(int i=0;i<list.size();i++)
        {
            ui->maopaopaixun->addItem(QString::number(list.at(i)));
        }
    });

    connect(quick,&QuickSort::finish,this,[=](QVector<int>list){

        for(int i=0;i<list.size();i++)
        {
            ui->kuaisupaixu->addItem(QString::number(list.at(i)));
        }
    });