QT 中如何正确使用QThread

最新推荐文章于 2024-07-16 23:09:18 发布
最新推荐文章于 2024-07-16 23:09:18 发布
阅读量1.7w 收藏 39
点赞数 10
分类专栏： QT

QThread看似类似于C++11的std::thread，实则大不相同。std::thread可以运行一个用户指定的函数；可以说比较的底层。而QThread则根本没有给出任何接口让你有机会指定你想运行的函数，因为它根本就不是为了运行用户指定的函数而生的，而是作为一个线程管理者，而很奇怪的是，这个管理者并不让你有机会指定你想运行的函数。也许有人说，继承QThread，然后重载run()函数，这不就可以了？事实上，这并不是正确的做法，也不是QThread存在的初衷。

那么，究竟怎样是正确的使用QThread呢？怎样才能让用户指定的函数作为一个独立线程运行起来呢？这篇QT的博客给出了详尽的解释。本文不打算再把此博文翻译一遍，而是打算给出一点自己的代码，当然，也是在原博文基础上做了一点点修改。最后指出一个原博文中没有提到的小坑。

首先，简单介绍一下使用QThread的正确方法：

第一步，写一个自己的类，继承QObject，然后在此类中定义一个自己想运行的方法，起什么名字都可以，没有限制。比如，在下文中，笔者将这个方法命名为void run().

第二步，因为此自定义类是继承了QObject的，所以可以调用moveToThread(QThread)方法，将整个自定义类的对象移到该QThread中。

第三步，做一系列的connect，主要是将QThread类的signal和自定义类的slot连接起来，详情可参见下面的代码。

第四步，调用QThread的start()启动新线程。

第五步，调用QThread的wait()方法使主线程阻塞。

具体详情请参见如下代码。

介绍一下整个工程。工程是QT的Console工程，除了.pro文件之外，还有三个文件：worker.h, worker.cpp和main.cpp. 具体代码如下：

1. TestQMutexQThread.pro

[plain] view plain copy
print ?
  1. QT += core  
  2. QT -= gui  
  3.   
  4. CONFIG += c++11  
  5.   
  6. TARGET = TestQSemaphore  
  7. CONFIG += console  
  8. CONFIG -= app_bundle  
  9.   
  10. TEMPLATE = app  
  11.   
  12. SOURCES += main.cpp \  
  13.     worker.cpp  
  14.   
  15. HEADERS += \  
  16.     worker.h  
QT += core
QT -= gui

CONFIG += c++11

TARGET = TestQSemaphore
CONFIG += console
CONFIG -= app_bundle

TEMPLATE = app

SOURCES += main.cpp \
    worker.cpp

HEADERS += \
    worker.h


2. worker.h

[cpp] view plain copy
print ?
  1. #ifndef MYTHREAD_H  
  2. #define MYTHREAD_H  
  3.   
  4. #include <QThread>  
  5. #include <QMutex>  
  6. #include <QUuid>  
  7. #include <QFile>  
  8. #include <QDir>  
  9.   
  10.   
  11. class Worker : public QObject  
  12. {  
  13.     Q_OBJECT  
  14.   
  15. private:  
  16.     static int myValue;  
  17.     static QMutex leds_mutex;  
  18.     QString m_id;  
  19.   
  20. public:  
  21.     Worker(QObject* parent = nullptr);  
  22.     ~Worker();  
  23.   
  24. public slots:  
  25.     void run();  
  26.   
  27. signals:  
  28.     void finished();  
  29.     void error(QString err);  
  30. };  
  31.   
  32. #endif // MYTHREAD_H  
#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QThread>
#include <QMutex>
#include <QUuid>
#include <QFile>
#include <QDir>


class Worker : public QObject
{
    Q_OBJECT

private:
    static int myValue;
    static QMutex leds_mutex;
    QString m_id;

public:
    Worker(QObject* parent = nullptr);
    ~Worker();

public slots:
    void run();

signals:
    void finished();
    void error(QString err);
};

#endif // MYTHREAD_H

3. worker.cpp

[cpp] view plain copy
print ?
  1. #include "worker.h"  
  2. #include <QDebug>  
  3.   
  4.   
  5. int Worker::myValue = 0;  
  6. QMutex Worker::leds_mutex;  
  7.   
  8. Worker::Worker(QObject* parent)  
  9.     : QObject(parent)  
  10.     , m_id(QUuid::createUuid().toString())  
  11. {  
  12. }  
  13.   
  14. Worker::~Worker()  
  15. {  
  16. }  
  17.   
  18. void Worker::run()  
  19. {  
  20.     int count = 0;  
  21.     while (count < 5) {  
  22.         ++count;  
  23.         Worker::leds_mutex.lock();  
  24.   
  25.         QFile file;  
  26.         QDir::setCurrent("C:/Users/YourUserName/Desktop");  
  27.         file.setFileName("1.txt");  
  28.         if (!file.open(QIODevice::Append | QIODevice::Text)) {  
  29.             qCritical() << "Failed to open file";  
  30.             Worker::leds_mutex.unlock();  
  31.             break;  
  32.         }  
  33.   
  34.         QTextStream out(&file);  
  35.         out     << "id: " << m_id << ", myValue = " << Worker::myValue << '\n';  
  36.         qInfo() << "id: " << m_id << ", myValue = " << Worker::myValue;  
  37.         ++Worker::myValue;  
  38.   
  39.         Worker::leds_mutex.unlock();  
  40.     }  
  41.   
  42.     emit finished();  
  43. }  
#include "worker.h"
#include <QDebug>


int Worker::myValue = 0;
QMutex Worker::leds_mutex;

Worker::Worker(QObject* parent)
    : QObject(parent)
    , m_id(QUuid::createUuid().toString())
{
}

Worker::~Worker()
{
}

void Worker::run()
{
    int count = 0;
    while (count < 5) {
        ++count;
        Worker::leds_mutex.lock();

        QFile file;
        QDir::setCurrent("C:/Users/YourUserName/Desktop");
        file.setFileName("1.txt");
        if (!file.open(QIODevice::Append | QIODevice::Text)) {
            qCritical() << "Failed to open file";
            Worker::leds_mutex.unlock();
            break;
        }

        QTextStream out(&file);
        out     << "id: " << m_id << ", myValue = " << Worker::myValue << '\n';
        qInfo() << "id: " << m_id << ", myValue = " << Worker::myValue;
        ++Worker::myValue;

        Worker::leds_mutex.unlock();
    }

    emit finished();
}

4. main.cpp

[cpp] view plain copy
print ?
  1. #include <QCoreApplication>  
  2. #include <QDebug>  
  3. #include <QScopedPointer>  
  4. #include "worker.h"  
  5.   
  6.   
  7. int main(int argc, char *argv[])  
  8. {  
  9.     QCoreApplication a(argc, argv);  
  10.   
  11.     QThread* t1 = new QThread;  
  12.     QThread* t2 = new QThread;  
  13.   
  14.     Worker* w1 = new Worker;  
  15.     Worker* w2 = new Worker;  
  16.   
  17.     w1->moveToThread(t1);  
  18.     w2->moveToThread(t2);  
  19.   
  20.     QObject::connect(t1, &QThread::started,  w1, &Worker::run);  
  21.     QObject::connect(w1, &Worker::finished,  t1, &QThread::quit);  
  22.     QObject::connect(w1, &Worker::finished,  [](){qInfo() << "w1 quit......";});  
  23.     QObject::connect(w1, &Worker::finished,  w1, &Worker::deleteLater);  
  24.     QObject::connect(t1, &QThread::finished, t1, &QThread::deleteLater);  
  25.   
  26.     QObject::connect(t2, &QThread::started,  w2, &Worker::run);  
  27.     QObject::connect(w2, &Worker::finished,  t2, &QThread::quit);  
  28.     QObject::connect(w2, &Worker::finished,  [](){qInfo() << "w2 quit......";});  
  29.     QObject::connect(w2, &Worker::finished,  w2, &Worker::deleteLater);  
  30.     QObject::connect(t2, &QThread::finished, t2, &QThread::deleteLater);  
  31.   
  32.   
  33.     t1->start();  
  34.     t2->start();  
  35.   
  36.     t1->wait(3);  
  37.     t2->wait(3);  
  38.   
  39.     qInfo() << "At the end of main thread...";    
  40.   
  41.     return 0;  
  42. }  
#include <QCoreApplication>
#include <QDebug>
#include <QScopedPointer>
#include "worker.h"


int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QThread* t1 = new QThread;
    QThread* t2 = new QThread;

    Worker* w1 = new Worker;
    Worker* w2 = new Worker;

    w1->moveToThread(t1);
    w2->moveToThread(t2);

    QObject::connect(t1, &QThread::started,  w1, &Worker::run);
    QObject::connect(w1, &Worker::finished,  t1, &QThread::quit);
    QObject::connect(w1, &Worker::finished,  [](){qInfo() << "w1 quit......";});
    QObject::connect(w1, &Worker::finished,  w1, &Worker::deleteLater);
    QObject::connect(t1, &QThread::finished, t1, &QThread::deleteLater);

    QObject::connect(t2, &QThread::started,  w2, &Worker::run);
    QObject::connect(w2, &Worker::finished,  t2, &QThread::quit);
    QObject::connect(w2, &Worker::finished,  [](){qInfo() << "w2 quit......";});
    QObject::connect(w2, &Worker::finished,  w2, &Worker::deleteLater);
    QObject::connect(t2, &QThread::finished, t2, &QThread::deleteLater);


    t1->start();
    t2->start();

    t1->wait(3);
    t2->wait(3);

    qInfo() << "At the end of main thread...";  

    return 0;
}

好了，源代码就这么多。自己定义的这个Worker::run()方法到底是如何作为一个线程跑起来的呢？关键点就在于main.cpp当中的这一堆的connect语句了。 首先，因为Worker类是继承了QObject类的，所以它可以调用moveToThread(QThread)方法将自身移到一个指定的QThread中去，而这个QThread要想真正运行起来，必须要调用start()方法。一旦调用了QThread的start方法， 就会有QThread的started信号（signal）发射出去，于是便会trigger这个Worker类的run()函数了。

以上这一段就是全部的精华了。

最后一个小坑：注意：在主线程中，有t1->wait(3)和t2->wait(3)这2句话。去查一下手册吧，wait()函数到底是干嘛的。其作用主要是使得主线程阻塞住，等待指定线程，即t1和t2的执行结束，或者超时。这都很好理解。注意，如果没有这2句wait()，主线程由于执行的太快，当子线程还没执行结束，主线程就已经结束退出进而导致整个进程结束了，那子线程自然也就终止了。不过，以上这些还不是笔者说的小坑。这里的小坑是，wait()必须给它填一个参数！如果不填参数的话，当然它有一个默认的参数，但是会导致子线程即使结束，主线程也仍然并将永远处于阻塞状态。这个不知道是否是QT的一个bug.但是，给wait()填一个数字作为参数，即使填上300，代表300秒，主线程也不会真正等上5分钟，而只是一旦子线程结束，主线程也就会解除阻塞，继续往下执行了。


（完）

l357630798
关注
  • 10
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Qt例程源代码QThread.7z
07-19
在Qt例程源代码QThread中，我们可以找到如何正确使用QThread的示例，包括线程的创建、启动、通信和终止。通过分析这些源码，开发者可以更深入地了解QThread的使用技巧，以及如何在实际项目中有效地利用多线程技术...
c++中的线程和QT中的线程
Christal_pyy的博客
11-30 809
子类对象移到线程中以启动线程。这是因为Qt的线程模型和C++11线程的设计思想在这一点上存在差异。所代表的线程中，并在那个线程中执行它的事件循环。的构造函数会立即启动线程，并且线程的生命周期与。时，不需要显式调用类似"start"的方法。的实例本身并不执行线程函数，而是通过将一个。子类对象移到新线程中来实现线程执行。在C++11及之后的标准中，这涉及到C++标准库中的。在构造时就启动线程，而。
如何正确使用QThread
FinixLei的专栏 (https://github.com/FinixLei)
05-31 6291
以代码解释了QThread的正确用法，并提示了其中的一个小坑。
QThread和std::thread
最新发布
Sakuya__的博客
07-16 704
在 Qt 中， 我们经常会用到多线程，这时候就需要纠结是使用 Qt 的 QThread 还是使用 C++ 标准库的 std::thread。这里记录一下我自己的理解，先介绍一下 QThread 和 std::thread 的使用方法，对比一下他们的不同，最后说一下我理解的应该怎么选择这两种方法。
性能特性测试系列4——QT线程与std::thread（下）之QThread
破晓前的彷徨
01-15 6878
序 一QThread 二两种用法 二互斥量锁条件变量原子操作及其他 三一张图 其实用法早就总结了，但是因为自身事务原因，一直没有比较他们间的效率，甚至各种互斥量，条件变量之间的效率，更多是集中看了下他们各自的api和特点，所以估计以后还需要补充或者是另开一篇来讲= =。序 QThread的线程用法上与std::thread相比有较大的区别，4.4版本之前是继承的方式来使用线程（个人猜测可能是因为那会
QT的几种线程
zh653的博客
09-03 937
1、QThread 使用QThread创建线程是我们最常见的一种方式，步骤如下： 继承QThread 重写run(）函数 通过start()函数启动线程 优点：可以通过信号槽与外界进行通信。 缺点：①每次新建一个线程都需要继承QThread，实现一个新类，使用不太方便。 ②要自己进行资源管理，线程释放和删除。并且频繁的创建和释放会带来比较大的内存开销。 适用场景：QThread适用于那些常驻内存的任务。 2、moveToThread moveToThread是在QThread的用法基础上扩展出来的，它是Q
QThread(QThreadPool)与std::thread比较
weixin_41502364的博客
08-02 206
现在有一个函数 fun(), 且希望将此函数运行在子线程中。
【C++ 与Qt 线程】C++ std::thread 与Qt qthread多线程混合编程
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-07 3653
C++与Qt深度融合：高效设计多线程应用框架
如何在QThread中使用控件
03-29
因此，了解如何正确地在QThread中使用控件对于提升应用程序的性能和用户体验至关重要。 首先，我们要明确一个概念：QThread主要是用来处理耗时任务，避免阻塞主线程，而不是直接操作GUI。Qt的设计原则是，所有的GUI...
在Qt（C++）中使用QThread实现多线程 - 星夜之夏 - 博客园1
08-03
- 在QThread中，`run()`函数是新线程的执行入口点。创建一个类继承自QThread，然后重写`run()`函数，将需要在线程中运行的代码放入`run()`内。 - 例如，创建一个名为`CopyFileThread`的类，包含一个`run()`函数来...
QT5线程QThread使用示例
12-10
这个示例展示了如何在QT5中使用`QThread`进行多线程编程，以及如何通过信号与槽机制在不同线程之间传递数据。注意，`QThread`的正确使用需要确保线程安全，避免数据竞争和死锁等问题。此外，线程的生命周期管理也...
QThread.rar_QT_QT 多线程_QThread 多线程_qthread_qt多线程
07-14
在VS2010这样的集成开发环境中，你需要确保配置好QT库，并设置正确的项目属性来链接到QT库。创建一个新的QT工程后，你可以引入`<QThread>`头文件，并实例化`QThread`对象。接着，可以创建一个继承自`QThread`的类，...
Python中QThread、Thread、Processing的比较总结
Konata的博客
07-18 5822
最近在学习PyQt相关知识，碰到了其中的QThread类。于是查找学习了Python中Thread类与Processing类的基础知识 1. Thread类 // TODO 2. Process类 // TODO 3. QThread类 在程序设计中，有时候有一些模块需要较长时间执行，例如文件传输等。在一个GUI程序中，如果直接使用简单的信号-槽(即简单事件响应机制)机制完成这类模块，那么在执行该模块时整个程序会陷入无响应，直到执行完成后才会恢复正常。 解决这种问题的好办法是引入多线程机制 基本用法 Q
c++线程的一些理解
苏州-青蛙
07-30 539
目前多线程方面我会用两种：Qt的QThread和std::thread，都是跨平台，封装了系统的线程库。 之后有必要会去了解Windows的thread和Linux的pthread。 线程同步方面主要使用互斥锁mutex和条件变量condition_variable，没有用到一定需要用信号量的场景且互斥锁效率不一定比读写锁差，所以所有项目我都只用互斥锁和条件变量基本都能实现需求。 互斥锁：保证临界区代码同时只能被一个线程访问。最常用的同步方式。 有一些注意的地方Winodows下,锁在同一个线程.
在Qt程序中使用C++11线程std::thread处理耗时操作
hw5230的博客
05-13 601
Qt界面程序通常什么情况下要使用到线程？Qt界面程序在调用接口处理时间较长的任务时(如连接网络、复制文件等等耗时操作)，界面在等待接口返回前会导致卡死。为了不让界面卡死，可以使用一个子线程来处理耗时任务，关于QThread的线程在这里就不介绍了，本文讲的使用std::thread来快速方便解决这个问题。解决问题思路1、现代大部分C++编译器已经支持C++11 的自带线程类std::thread，线程随时创建，随时销毁方便。
Qt 多线程之 std::thread (一)
tomhibolu
07-08 1093
不时见到有人会这样做： 不使用QThread，而是使用pthread等平台相关的底层 api 而又不想使用底层线程间同步、通讯的api 那么，如何使用pthread，而又使用Qt提供的线程间机制呢？ 本文的初衷源于此，但是使用的的是C++0x 的 std::thread，而不是直接使用unix的pthread。(既然用Qt，还是尽量保证夸平台吧) 不想写太多的文字，还是用一个一个...
记录在Qt中使用std::thread的一个例子
LYQ1400578281的博客
12-02 1511
Qt中使用std::thread的一个例子
QT实战——多线程学习笔记（二）
weixin_44898655的博客
07-17 1011
QT实战——多线程学习笔记，介绍了多线程在C++11中的函数，以及对多线程之间如何实现通信进行介绍
qt 释放QThread
08-23
在Qt中释放QThread的主要步骤如下: 1. 停止线程的执行: 首先，需要调用QThread的`quit()`或`exit()`方法，来停止线程的执行。这会导致线程的事件循环退出。 2. 等待线程的结束: 使用`wait()`方法来等待线程的结束。...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值