Qt创建线程(使用moveToThread方法创建子线程)

1.moveTothread方法:

（1）要使用moveToThread方法必须继承与QObject类

（2）创建任务对象时不能指定父对象

例子：

MyWork* work = new MyWork(this); // error

MyWork* work = new MyWork; // ok

（3）任务类里面的任务函数可以有多个

（4）这种创建线程的方式很灵活，如果子线程不够用，可以把多个任务函数移动到其中的一个线程中，（一个子线程中可以移动多个任务函数，关联的多个任务函数是按照线性的顺序执行的）还可以先在线程1中执行任务函数a，然后在线程2中执行任务函数a(也就是一个任务函数可以在多个不同的线程中执行)

QThread和moveToThread两种方法都可以使用信号和槽

2.使用moveToThread方法实现点击开始按钮生成10000个随机数，然后分别使用冒泡排序和快速排序排序这10000个随机数，最后在窗口显示排序后的数字：

mainwindow.h文件：

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include 

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

mythread.h文件：

#ifndef MYTHREAD_H
#define MYTHREAD_H
#include
#include 
//生成随机数 第二种写法继承于QObject实现的多线程
class MyThread : public QObject
{
    Q_OBJECT
public:
    explicit MyThread(QObject *parent = nullptr);
    void working(int num);
signals:
    void sendArray(QVector list);
};

class BubbleSort : public QObject
{
    Q_OBJECT
public:
    explicit BubbleSort(QObject *parent = nullptr);
    void working(QVector list);
signals:
    void finish(QVector num);
};

class QuickSort : public QObject
{
    Q_OBJECT
public:
    explicit QuickSort(QObject *parent = nullptr);
     void working(QVector list);
private:
    void quickSort(QVector &list, int l, int r);
signals:
    void finish(QVector num);
};

#endif // MYTHREAD_H

main.cpp文件：

#include "mainwindow.h"

#include 

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

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "mythread.h"
#include
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    //1.创建子线程的对象
    QThread *t1 = new QThread;
    //QThread *t1 = new QThread(this); //1.创建子线程时指定父对象为this就可以在线程结束时自动释放线程
    //2.在当前窗口析构的时候，回收线程的资源
    QThread *t2 = new QThread;
    QThread *t3 = new QThread; //创建三个子线程，现在系统中一共有四个线程（三个子线程和一个主线程）

    //2.创建任务类的对象
    MyThread *gen = new MyThread;
    BubbleSort *bubble = new BubbleSort;
    QuickSort *quick = new QuickSort;

    //3.将任务对象移动到某个子线程中
    gen->moveToThread(t1);
    bubble->moveToThread(t2);
    quick->moveToThread(t3);

    connect(this, &MainWindow::starting, gen, &MyThread::working);
    //2.启动子线程
    connect(ui->start, &QPushButton::clicked, this, [=]{
        emit starting(10000); //在启动子线程时，将要生成的随机数的个数发送出去
        t1->start();

    });
    //接收子线程发送的数据

    connect(gen, &MyThread::sendArray, bubble, &BubbleSort::working); //先关联再启动线程
    connect(gen, &MyThread::sendArray, quick, &QuickSort::working); //这里任务函数是在子线程中执行的
   /* connect(gen, &MyThread::sendArray, this,[](QVector list){//如果信号和槽函数不在同一个线程的情况
        bubble->working(list);
        quick->working(list);
    }); *///注意：此时这个匿名函数是在当前的主线程中执行的，但是我们是想让他在子线程中执行，这样就错误了，不满足我们的需求了


    connect(gen, &MyThread::sendArray, this, [=](QVector list){ //connect里面不支持传递QVector类型//需要使用qRegisterMetaType()进行注册
        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 list){ //connect里面不支持传递QVector类型//需要使用qRegisterMetaType()进行注册
        for(int i = 0; i < list.size(); i++){
            ui->bubbleList->addItem(QString::number(list.at(i)));
        }
    });
    connect(quick, &QuickSort::finish, this, [=](QVector list){ //connect里面不支持传递QVector类型//需要使用qRegisterMetaType()进行注册
        for(int i = 0; i < list.size(); i++){
            ui->quickList->addItem(QString::number(list.at(i)));
        }
    });

    //2.当前窗口析构的时候，回收线程的资源
    //窗口关闭时，会发送一个destroyed()信号，就可以根据这个信号来销毁线程的资源
    connect(this, &MainWindow::destroyed, this,[=]{
        t1->quit();
        t1->wait();
        t1->deleteLater(); //delete t1 销毁线程t1的资源

        t2->quit();
        t2->wait();
        t2->deleteLater(); //delete t2 销毁线程t2的资源

        t3->quit();
        t3->wait();
        t3->deleteLater(); //delete t3 销毁线程t3的资源

        gen->deleteLater(); //释放任务对象gen
        bubble->deleteLater(); //释放任务对象bubble
        quick->deleteLater(); //释放任务对象quick

    });
    \
}


MainWindow::~MainWindow()
{
    delete ui;
}

mythread.cpp文件：

#include "mythread.h"
#include 
#include  //计算某个流程执行所使用的时间
#include 
#include 
MyThread::MyThread(QObject *parent)
    : QObject(parent)
{

}

void MyThread::working(int num)
{
    qDebug() << "生成随机数的线程地址" << QThread::currentThread(); //获取一个指针，这个指针指向当前线程对象的地址
    QVector 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 list)
{
    qDebug() << "冒泡排序的线程地址" << QThread::currentThread(); //获取一个指针，这个指针指向当前线程对象的地址
    QElapsedTimer time;
    time.start();
    for(int i = 0; i < list.size() - 1 ;i++){
        for(int j = 0;j < list.size() - i - 1; j++){
            if(list[j] > list[j + 1]){
                int 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::quickSort(QVector &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);
    }
}

void QuickSort::working(QVector list)
{
    qDebug() << "快速排序的线程地址" << QThread::currentThread(); //获取一个指针，这个指针指向当前线程对象的地址
    QElapsedTimer time;
    time.start();
    quickSort(list, 0,list.size()-1);
    int milsec = time.elapsed();
    qDebug() << "快速排序用时" << milsec << "毫秒";
            emit finish(list);
}

运行结果：