Qt学习之路---QThread

QThread 是 Qt 框架中用于创建和管理线程的类。它提供了一种方便的方式来执行并发任务，并允许你在多线程环境中编写应用程序。QThread 类封装了底层平台特定的线程实现，并提供了一些高级特性，如事件循环和线程间通信。

Qthread 官网：

QThread Class | Qt Core 5.15.14

public fun（常用函数）

QThread(QObject *parent = nullptr)
virtual	~QThread()	构造函数
void	exit(int returnCode = 0)	退出线程的事件循环
bool	isFinished() const	判断线程是否完成
bool	isRunning() const	判断线程是否在运行
int	loopLevel() const	返回线程的当前事件循环级别。 注意:这只能在线程本身内调用，即当它是当前线程时。
QThread::Priority	priority() const	返回正在运行的线程的优先级。如果线程没有运行，这个函数返回InheritPriority。
void	requestInterruption()	请求线程中断
void	setPriority(QThread::Priority priority)	设置线程的优先级
void	setStackSize(uint stackSize)	设置线程堆栈的大小，如果超过这个大小，线程不会工作
uint	stackSize() const	返回最大线程堆栈的大小
bool	wait(QDeadlineTimer deadline = QDeadlineTimer(QDeadlineTimer::Forever))	阻塞线程

Public Slots 

void	quit()	和exit函数功能相似
void	start(QThread::Priority priority = InheritPriority)	通过调用run开始执行线程
void	terminate()	终止线程的执行。线程可以立即终止，也可以不立即终止，这取决于操作系统的调度策略。在terminate()之后使用QThread::wait()来确保。 当线程终止时，所有等待线程结束的线程都将被唤醒。

Signals 

void	finished()	线程结束后发出
void	started()	线程开始时发出

Static Public Members 

QThread *	create(Function &&f)	创建线程，执行函数f，使用start执行
QThread *	currentThread()	返回一个指向管理当前执行线程的QThread的指针。
int	idealThreadCount()	返回可在系统上运行的理想线程数。
void	yieldCurrentThread()	将当前线程的执行转交给另一个可运行线程(如果有的话)。注意，操作系统决定切换到哪个线程。
延时函数
void	msleep(unsigned long msecs)	毫秒
void	sleep(unsigned long secs)	秒
void	usleep(unsigned long usecs)	纳秒

 Protected Functions

int	exec()	进入事件循环并等待exit()被调用，返回传递给exit()的值。如果通过quit()调用exit()，返回值为0。 这个函数应该在run()中调用。
virtual void	run()	线程的起始点

 线程的优先级

QThread::IdlePriority	0	scheduled only when no other threads are running.
QThread::LowestPriority	1	scheduled less often than LowPriority.
QThread::LowPriority	2	scheduled less often than NormalPriority.
QThread::NormalPriority	3	the default priority of the operating system.
QThread::HighPriority	4	scheduled more often than NormalPriority.
QThread::HighestPriority	5	scheduled more often than HighPriority.
QThread::TimeCriticalPriority	6	scheduled as often as possible.
QThread::InheritPriority	7	use the same priority as the creating thread. This is the default.

QThread对象管理程序中的一个控制线程。QThreads在run()中开始执行。默认情况下，run()通过调用exec()启动事件循环，并在线程内运行Qt事件循环。

您可以通过使用QObject::moveToThread()将工作对象移动到线程中来使用它们。

示例

运行结果

代码

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <list>
#include <QRandomGenerator>
#include <QTimer>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

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


private slots:
    void pro_random();
    void on_btn_begin_clicked();

    void on_btn_stop_clicked();

    void on_btn_re_clicked();

signals:
    void randomOk(std::list<int>);

private:
    Ui::MainWindow *ui;
    std::list<int> list;
    QTimer *timer;
};

#endif // MAINWINDOW_H

 mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QThread>
#include <QRandomGenerator>
#include <QTimer>
#include "sort.h"

static int count = 0;

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    //初始化定时器对象，并设置1000ms延时，每秒产生一次timeout信号
    timer = new QTimer(this);
    timer->setInterval(1000);
    connect(timer,&QTimer::timeout,this,&MainWindow::pro_random);
    Aces *acse = new Aces(this);
    connect(acse,&Aces::acse_success,this,[=](std::list<int> list_a, std::list<int> list_d){
        ui->text_asce->clear();
        ui->text_desc->clear();
        for (auto i : list_a)
        {
            ui->text_asce->append(QString::number(i));
        }
        for (auto i : list_d)
        {
            ui->text_desc->append(QString::number(i));
        }
    });
    acse->start();
}

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

void MainWindow::pro_random()
{
    QRandomGenerator *tor = QRandomGenerator::system();
    int num = tor->bounded(100);
    list.push_back(num);
    ui->text_random->append(QString::number(num));
    emit randomOk(list);
    count++;
    if (count == 10)
    {
        timer->stop();
    }
}
//开始生成
void MainWindow::on_btn_begin_clicked()
{
    timer->start();
}

//停止生成
void MainWindow::on_btn_stop_clicked()
{
    timer->stop();
}

//重新生成
void MainWindow::on_btn_re_clicked()
{
    ui->text_random->clear();
    ui->text_asce->clear();
    ui->text_desc->clear();
    count = 0;
    list.clear();
    timer->start();
}

sort.h

#ifndef SORT_H
#define SORT_H

#include <QThread>
#include <QObject>
#include <list>
#include "mainwindow.h"


//升序
class Aces : public QThread
{
    Q_OBJECT
public:
    explicit Aces( MainWindow *mainwindow, QObject *parent = nullptr);
protected:
    void run() override;

signals:
    void acse_success(std::list<int>, std::list<int>);
public slots:
private:
    MainWindow *mainwindow;
};

#endif // SORT_H

sort.cpp

#include "sort.h"
#include <functional>


Aces::Aces( MainWindow *mainwindows, QObject *parent) : QThread(parent),
    mainwindow(mainwindows)
{

}

void Aces::run()
{

    connect(mainwindow,&MainWindow::randomOk,this,[=](std::list<int> list){
        std::list<int> acse_list(list);
        acse_list.sort();
        std::list<int> dcse_list(list);
        dcse_list.sort(std::greater<int>());
        emit acse_success(acse_list, dcse_list);
    });
    //开始事务循环
    exec();
}