Qt开发 | Qt创建线程 | Qt并发-QtConcurrent

标签：run Qt int QtConcurrent concurrent 线程 include

文章目录

一、Qt创建线程的三种方法
二、Qt并发：QtConcurrent介绍
三、QtConcurrent run参数说明
四、获取QtConcurrent的返回值
五、C++其他线程技术介绍

一、Qt创建线程的三种方法

以下是Qt创建线程的三种方法：

方法一：派生于QThread

派生于QThread，这是Qt创建线程最常用的方法。线程类中重写虚函数void QThread::run();，在run()函数中写具体内容，外部通过start()调用，即可执行线程体run()。

注意：派生于QThread的类，构造函数属于主线程，run函数属于子线程，可以通过打印线程id来判断

示例：

VS中创建Qt控制台项目

MyThread.h：

#pragma once

#include <QThread>

class MyThread : public QThread
{
public:
	MyThread();
	void run()override;
};

MyThread.cpp：

#include "MyThread.h"
#include <QDebug>

MyThread::MyThread()
{
	qDebug() << "MyThread construct id =" << QThread::currentThreadId;
}

void MyThread::run()
{
	qDebug() << "MyThread run id =" << QThread::currentThreadId;
	int index = 0;
	while (1)
	{
		qDebug() << index++;
		QThread::msleep(500);
	}
}

main.cpp：

#include <QtCore/QCoreApplication>
#include <QDebug>
#include "MyThread.h"


int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    qDebug() << "main thread id = " << QThread::currentThreadId;

    MyThread th;
    th.start();

    qDebug() << "main thread end!";
    return a.exec();
}

运行结果：

main thread id =  0x78272815
MyThread construct id = 0x78272815
main thread end!
MyThread run id = 0x78272815
0
1
2
3
4
5
6
...

方法二：派生于QRunnable

派生于QRunnable，重写run()方法，在run()方法里处理其他任务，调用时需要借助Qt线程池

注意：这种新建线程的方法的最大缺点是：不能使用Qt信号槽机制，因为QRunnable不是继承自QObject。但是这种方法的好处是：可以让QThreadPool来管理线程，QThreadPool会自动清理我们新建的QRunnable对象。

示例：

MyRunnable.h：

#pragma once

#include <QRunnable>

class MyRunnable : public QRunnable
{
public:
	MyRunnable();
	void run()override;
};

MyRunnable.cpp：

#include "MyRunnable.h"
#include <QThread>
#include <QDebug>

MyRunnable::MyRunnable()
{
	qDebug() << "MyRunnable construct id =" << QThread::currentThreadId;
}

void MyRunnable::run()
{
	qDebug() << "MyRunnable run id =" << QThread::currentThreadId;
}

main.cpp：

#include <QtCore/QCoreApplication>
#include <QDebug>
#include <QThreadPool>
#include "MyThread.h"
#include "MyRunnable.h"


int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    qDebug() << "main thread id = " << QThread::currentThreadId;

    //MyThread th;
    //th.start();

    MyRunnable* th = new MyRunnable();
    QThreadPool::globalInstance()->start(th);

    qDebug() << "main thread end!";
    return a.exec();
}

运行结果：

main thread id =  0x78272815
MyRunnable construct id = 0x78272815
main thread end!
MyRunnable run id = 0x78272815

方法三：moveToThread

派生于QObject，使用moveToThread方法将任何QObject派生类的实例移动到另一个线程。将QThread对象作为私有成员，在构造函数里moveToThread，然后启动线程。

QThread *thread = new QThread;
this->moveToThread(thread);
thread->start();

示例：

MyObject.h：

#pragma once
#include <qobject.h>
#include <QThread>

class MyObject : public QObject
{
	Q_OBJECT
public:
	MyObject();

public slots:
	void process();

private:
	QThread m_pTh;
};

MyObject.cpp：

#include "MyObject.h"
#include <QDebug>

MyObject::MyObject()
{
	this->moveToThread(&m_pTh);
	m_pTh.start();

	qDebug() << "MyObject construct id = " << QThread::currentThreadId();
}

void MyObject::process()
{
	qDebug() << "MyObject process id = " << QThread::currentThreadId();
	
	int index = 0;
	while (1)
	{
		qDebug() << index++;
		QThread::msleep(300);
	}
}

ch7_1_mtt.h：

#pragma once

#include <QtWidgets/QWidget>
#include "ui_ch7_1_mtt.h"
#include "MyObject.h"

class ch7_1_mtt : public QWidget
{
    Q_OBJECT

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

public slots:
    void on_pushButton_clicked();

signals:
    void sig_pro();

private:
    Ui::ch7_1_mttClass ui;
    MyObject* m_pObj;
};

ch7_1_mtt.cpp：

#include "ch7_1_mtt.h"
#include <QDebug>


ch7_1_mtt::ch7_1_mtt(QWidget *parent)
    : QWidget(parent)
{
    ui.setupUi(this);
    qDebug() << "main construct id = " << QThread::currentThreadId();

    m_pObj = new MyObject();

    connect(this, &ch7_1_mtt::sig_pro, m_pObj, &MyObject::process);
}

ch7_1_mtt::~ch7_1_mtt()
{}

void ch7_1_mtt::on_pushButton_clicked()
{
    //通过信号槽方式调用，相当于在子线程中运行；若直接调用process()函数，则相当于在主线程中运行
    emit sig_pro();
}

在槽函数中进行耗时操作可以使用线程，在子线程中进行耗时操作

main.cpp：

#include "ch7_1_mtt.h"
#include <QtWidgets/QApplication>

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

运行结果：

main construct id = 0x52dc
MyObject construct id =  0x52dc
MyObject process id =  0x78272815
0
1
2
3
4
5
6
7

二、Qt并发：QtConcurrent介绍

QtConcurrent是Qt框架中的一个模块，用于简化并发和多线程编程。它提供了一种高效的方式来执行并行任务，而无需直接处理线程的复杂性。QtConcurrent基于模板和函数式编程，使得编写并发代码更加简洁和易于理解。以下是QtConcurrent的一些关键特性：

基于模板的并行算法：QtConcurrent提供了一系列的并行算法，如QtConcurrent::map()、QtConcurrent::filter()和QtConcurrent::reduce()等，它们可以并行地对数据集执行操作。
基于Qt的线程池管理：QtConcurrent使用Qt的线程池来管理线程，这意味着开发者不需要手动创建和销毁线程，从而简化了线程管理。
信号和槽的集成：QtConcurrent可以与Qt的信号和槽机制无缝集成，使得并行任务的结果可以很容易地通过信号传递给其他对象。
懒加载和任务取消：QtConcurrent支持懒加载，即任务只有在实际需要结果时才开始执行。此外，它还支持取消正在执行的任务。
异常处理：QtConcurrent可以处理并行执行过程中抛出的异常，确保程序的健壮性。
无阻塞的等待：QtConcurrent提供了一种机制来等待并行任务的完成，而不会阻塞调用线程。

Header:
#include <QtConcurrent> 
qmake:
QT += concurrent

QtConcurrent基本用法：

QtConcurrent::run这行代码的作用是启动ch72_concurrent类的timeTask成员函数在单独的线程中异步执行，并且返回一个QFuture<int>对象，用于跟踪执行的状态和获取返回值。

QFuture<int> ft = QtConcurrent::run(this, &ch72_concurrent::timeTask);

while (!ft.isFinished())
{
    //用于处理事件队列中的事件的。这个函数可以确保应用程序界面保持响应状态，即使在执行长时间运行的任务时
    //当future未完成时，让cpu去做别的事
    QApplication::processEvents(QEventLoop::AllEvents, 30); 
}

示例：

xx.h：

#pragma once

#include <QtWidgets/QWidget>
#include "ui_ch72_concurrent.h"

class ch72_concurrent : public QWidget
{
    Q_OBJECT

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

    int timeTask();

private slots:
    void on_pushButton_clicked();

private:
    Ui::ch72_concurrentClass ui;
};

xx.cpp：

#include "ch72_concurrent.h"
#include <QThread>
#include <QDebug>
#include <QtConcurrent>
#include <QFuture>

ch72_concurrent::ch72_concurrent(QWidget *parent)
    : QWidget(parent)
{
    ui.setupUi(this);
}

ch72_concurrent::~ch72_concurrent()
{}

int ch72_concurrent::timeTask()
{
    int num = 0;
    for (int i = 0; i < 1000000; i++)
    {
        num++;
        qDebug() << num;
    }

    return num;
}

void ch72_concurrent::on_pushButton_clicked()
{
    //timeTask();

    QFuture<int> ft = QtConcurrent::run(this, &ch72_concurrent::timeTask);

    while (!ft.isFinished())
    {
        //用于处理事件队列中的事件的。这个函数可以确保应用程序界面保持响应状态，即使在执行长时间运行的任务时
        QApplication::processEvents(QEventLoop::AllEvents, 30); 
    }
}

main.cpp：

#include "ch72_concurrent.h"
#include <QtWidgets/QApplication>

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

三、QtConcurrent run参数说明

QtConcurrent run函数参数，可以是全局函数，也可以是类成员函数。

类成员函数做run参数

int ch73_concurrent::timeTask(int num1, int num2)
{
    //int num = 0;
    for (int i = 0; i < 1000000; i++)
    {
        num1++;
        num2++;
        qDebug() << num1;
        qDebug() << num2;
    }

    return num1 + num2;
}

void ch73_concurrent::on_pushButton_clicked()
{
    //timeTask();

    int num1 = 0;
    int num2 = 0;
    QFuture<int> ft = QtConcurrent::run(this, &ch73_concurrent::timeTask, num1, num2);

    while (!ft.isFinished())
    {
        QApplication::processEvents(QEventLoop::AllEvents, 30);
    }
}

全局函数做run参数

static int gTimeTask(int num1, int num2)
{
    //int num = 0;
    for (int i = 0; i < 1000000; i++)
    {
        num1++;
        num2++;
        qDebug() << num1;
        qDebug() << num2;
    }

    return num1 + num2;
}

void ch73_concurrent::on_pushButton_clicked()
{
    //timeTask();

    int num1 = 0;
    int num2 = 0;
    //QFuture<int> ft = QtConcurrent::run(this, &ch73_concurrent::timeTask, num1, num2);
    QFuture<int> ft = QtConcurrent::run(gTimeTask, num1, num2);

    while (!ft.isFinished())
    {
        QApplication::processEvents(QEventLoop::AllEvents, 30);
    }
}

四、获取QtConcurrent的返回值

获取QtConcurrent的结果，需要使用QFutureWatcher类，链接它的信号finished，然后给watcher设置future，当监控到future执行结束后，可以获取它的执行结果，调用的是result()函数。

int ch74::timeTask(int& num1, int& num2)
{
    for (int i = 0; i < 1000; i++)
    {
        num1++;
        num2++;
        qDebug() << num1;
        qDebug() << num2;
    }

    return num1 + num2;
}

void ch74::on_pushButton_clicked()
{
    int num1 = 0;
    int num2 = 0;

    QFutureWatcher<int>* fw = new QFutureWatcher<int>;

    connect(fw, &QFutureWatcher<int>::finished, [&]{
        qDebug() << "QFutureWatcher finished";
        qDebug() << "result = " << fw->result();
        });

    QFuture<int> ft = QtConcurrent::run(this, &ch74::timeTask, num1, num2);
    fw->setFuture(ft);

    while (!ft.isFinished())
    {
        QApplication::processEvents(QEventLoop::AllEvents, 30);
    }
}

五、C++其他线程技术介绍

pthread：linux线程
- 这是POSIX线程库，主要用于Unix-like系统，如Linux和macOS。
- 提供了丰富的线程创建和管理功能，包括互斥锁、条件变量等同步机制。
win32-pthread，obs的线程全部使用了win32-pthread
- 这是一个在Windows平台上模拟POSIX线程库的库。
- OBS（Open Broadcaster Software）等应用程序使用这个库来实现跨平台的线程功能。
windows thread类
- Windows API提供了自己的线程类，如Win32 Thread，用于创建和管理线程。
- 这些线程类通常与Windows特定的功能紧密结合，如窗口消息处理。
MFC thread类
- MFC（Microsoft Foundation Classes）是一套C++库，用于Windows应用程序开发。
- MFC提供了自己的线程类，例如CWinThread，用于简化线程的创建和管理。
boost
- Boost库是一个广泛使用的C++库集合，其中包含了线程库。
- Boost.Thread提供了跨平台的线程支持，包括线程创建、同步等。
std::thread（推荐使用这个，基于语言级别的跨平台C++线程）
- C++11标准引入了std::thread，这是语言级别的线程支持。
- 推荐使用std::thread，因为它提供了跨平台的线程支持，并且与C++标准库紧密集成。
- std::thread简化了线程的创建和管理，同时提供了丰富的同步机制，如std::mutex、std::condition_variable等。

标签：run,Qt,int,QtConcurrent,concurrent,线程,include
From： https://blog.csdn.net/zwcslj/article/details/140278967

Qt开发 | Qt创建线程 | Qt并发-QtConcurrent

文章目录

一、Qt创建线程的三种方法

二、Qt并发：QtConcurrent介绍

三、QtConcurrent run参数说明

四、获取QtConcurrent的返回值

五、C++其他线程技术介绍

相关文章

赞助商

阅读排行