【零基础QT学习_QThread】

QThread常用函数

名称	定义
void QThread::start(QThread::Priority priority = InheritPriority)	通过调用run()开始执行线程。操作系统会根据参数中设置的优先级调度线程。如果线程已经在运行，那这个函数说明都不做。优先级参数的效果取决于操作系统的调度策略。在不支持线程优先级的系统上，优先级将被忽略（如 Linux系统 ）。
void quit()	结束线程的执行。如果线程在等待事件，这会导致它返回到事件循环并退出。如果线程没有进行事件循环，函数不执行任何操作。
bool wait(unsigned long time = ULONG_MAX)	等待线程结束
[static] void msleep(unsigned long msecs) （毫秒）[static] void sleep(unsigned long secs) （秒）[static] void usleep(unsigned long usecs) （微秒）	强制当前线程休眠。如果需要等待某个条件的达成，则应避免使用此函数改用信号槽。此功能不保证准确性。
void QThread::exit(int returnCode = 0)	执行结束线程，并返回状态
bool QThread::isFinished() const	检查线程是否已经完成执行
void QThread::setPriority(Priority priority)	设置线程的优先级
Priority QThread::priority() const	获取线程的优先级
void QThread::setStackSize(uint stackSize)	设置线程的栈大小
uint QThread::stackSize() const	获取线程栈的大小
void QThread::setObjectName(const QString &name)	设置线程的名称
QString QThread::objectName() const	获取线程的名称
void QThread::setLoopLevels(int level)	设置线程循环的嵌套级别
int QThread::loopLevel() const	获取线程循环的嵌套级别
bool QThread::isRunning() const	检测线程是否正在运行
bool QThread::isFinished() const	检测线程是否已完成
PID QThread::pid() const	获取线程的进程ID
TID QThread::tid() const	获取线程的线程ID
void QThread::setEventDispatcher(QEventDispatcher *eventDispatcher)	设置事件的分发器
QEventDispatcher *QThread::eventDispatcher() const	获取事件的分发器
int QThread::exec()	运行事件循环直到调用exit()
void QThread::terminate()	尝试立即停止线程的执行，但是，如果这个函数不会立即停止线程，他设置一个标志，表示一个停止线程
void QThread::requestInterruption()	请求终端线程的执行
bool QThread::isInterruptionRequested() const	检测是否请求中断线程
bool QThread::create(Priority priority = InheritPriority)	创建一个新的线程，并设置优先级

实现效果

1、随机数处创建了一个线程在单独运行；
2、线程2和UI主界面为一个线程；

注意事项

###如何调用创建好的线程

***.h
private :
  //创建线程和CHdlMsg类
   QThread *m_d1;
   CHdlMsg *m_hdlMsg;

.cpp
CMainWidget::CMainWidget(QWidget *parent)
	: QMainWindow(parent)
{
  // 创建后，分配内存空间；
    m_d1=new QThread;
    m_hdlMsg = new CHdlMsg();
    
     //将m_hdlMsg任务添加到线程m_d1中
    m_hdlMsg->moveToThread(m_d1);  
    
    //程序结束后，自动结束线程，释放线程内存空间
    connect(this,&CMainWidget::destroyed,this,[=]
    {
         m_d1->quit();
         m_d1->wait();
         m_d1->deleteLater();
         m_hdlMsg->deleteLater();
  });
  
  //启动线程
   m_hdlMsg->start();  
}

CMainWidget::~CMainWidget
{
//释放m_hdlMsg内存空间，并且删除内存空间后，将其赋值为空；
    if（m_hdlMsg！=nullptr）
    {
         delete m_hdlMsg;
        m_hdlMsg nullptr;
   }

}

代码实现

//main.cpp
#include "mainwindow.h"

#include <QApplication>

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

//MainWindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include<QThread>
#include<windows.h>
#include"hdl_generate.h"

QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

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

public:
    void connt();

public slots:
    void slot_ReceiveArray(QVector<int> randList);

private slots:
    void on_pbut_start_clicked();

    void on_pbut_end_clicked();

private:
    Ui::MainWindow *ui;
    CHdlGenerate *m_hdlGene;

    QVector<int> m_receicelist;

	QThread *t1;

    bool m_runing=false;

};
#endif // MAINWINDOW_H

//mainwindow.cpp
#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    m_hdlGene = new CHdlGenerate(nullptr);
    t1 = new QThread;
    m_hdlGene->moveToThread(t1);
    connt();
}

MainWindow::~MainWindow()
{
    delete ui;
    if(m_hdlGene!=nullptr)
    {
        delete m_hdlGene;
        m_hdlGene=nullptr;
    }
}

void MainWindow::connt()
{
connect(m_hdlGene,SIGNAL(signal_SendArray(QVector<int>)),this,SLOT(slot_ReceiveArray(QVector<int>)),Qt::DirectConnection);
    connect(this,&MainWindow::destroyed,this,[=]{
        t1->quit();
        t1->wait();
        t1->deleteLater();
        m_hdlGene->deleteLater();
    });
}

void MainWindow::slot_ReceiveArray(QVector<int> randList)
{
    cout<<"slot_receiveArray"<<endl;
    m_receicelist= randList;
    for(int i=0;i<m_receicelist.size();i++)
    {
        ui->list_gene->addItem(QString::number(m_receicelist.at(i)));
		Sleep(100);
    }
}

void MainWindow::on_pbut_start_clicked()
{
    m_hdlGene->start();
}

void MainWindow::on_pbut_end_clicked()
{
    if(ui->pbut_end->text()==QString::fromLocal8Bit("UI开始"))
    {
        ui->pbut_end->setText(QString::fromLocal8Bit("UI结束"));
        ui->pbut_end->setStyleSheet("background-color:rgb(223,23,222)");
        for(int i=0; i<50000; i++)
        {
            ui->listWidget->addItem(QString::number(i));
        }

    }else
    {
        ui->pbut_end->setText(QString::fromLocal8Bit("UI开始"));
        ui->pbut_end->setStyleSheet("background-color:rgb(255,255,255)");
    }
}

//hdl_generate.h
#ifndef CHDLGENERATE_H
#define CHDLGENERATE_H

#include <QObject>
#include<QThread>
#include<QElapsedTimer>
#include<QVector>
#include<iostream>
using namespace std;

class CHdlGenerate : public QThread
{
    Q_OBJECT
public:
  CHdlGenerate(QObject *parent=nullptr);
  ~CHdlGenerate();

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

protected:
    void run() override;

private:
    int m_num=1000;
    bool m_running=false;
};

#endif // CHDLGENERATE_H

//hdl_generate.cpp
#include "hdl_generate.h"
CHdlGenerate::CHdlGenerate(QObject *parent):QThread(parent)
{
    m_running=true;
}

CHdlGenerate::~CHdlGenerate()
{
    m_running=false;
}

void CHdlGenerate::run()
{
     while(m_running)
  {
        cout<<"生成随机数的线程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();
        cout<<"生成"<<m_num<<"个随机数总共用时:"<<m_delaytime<<"毫秒";
        emit signal_SendArray(randList);
     }
}