Qt 线程 QThread类详解

丝  金牌会员 | 2024-7-14 07:01:45 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 638|帖子 638|积分 1914

Qt 线程中QThread的使用

在进行桌面应用程序开辟的时候， 假设应用程序在某些情况下需要处理比力复杂的逻辑， 如果只有一个线程行止理，就会导致窗口卡顿，无法处理用户的相干操作。这种情况下就需要使用多线程，其中一个线程处理窗口事故，其他线程进行逻辑运算，多个线程各司其职，不光可以提高用户体验还可以提拔程序的实行服从。
在 qt 中使用了多线程，有些事项是需要额外注意的：


  • 默认的线程在Qt中称之为窗口线程，也叫主线程，负责窗口事故处理或者窗口控件数据的更新
  • 子线程负责后台的业务逻辑处理，子线程中不能对窗口对象做任何操作，这些变乱需要交给窗口线程处理
  • 主线程和子线程之间如果要进行数据的通报，需要使用Qt中的信号槽机制
1. 线程类 QThread

Qt 中提供了一个线程类，通过这个类就可以创建子线程了，Qt 中一共提供了两种创建子线程的方式，后边会依次介绍其使用方式。先来看一下这个类中提供的一些常用 API 函数：
  1. // Qt中的线程可以设置优先级
  2. // 得到当前线程的优先级
  3. Priority QThread::priority() const;
  4. void QThread::setPriority(Priority priority);
  5. 优先级:
  6.     QThread::IdlePriority         --> 最低的优先级
  7.     QThread::LowestPriority
  8.     QThread::LowPriority
  9.     QThread::NormalPriority
  10.     QThread::HighPriority
  11.     QThread::HighestPriority
  12.     QThread::TimeCriticalPriority --> 最高的优先级
  13.     QThread::InheritPriority      --> 子线程和其父线程的优先级相同, 默认是这个
  16. start(): 启动线程，使线程进入运行状态，调用线程的run()方法。
  17. run(): 线程的执行函数，需要在该函数中编写线程所需执行的任务。
  18. quit(): 终止线程的事件循环，在下一个事件处理周期结束时退出线程。
  19. wait(): 阻塞当前线程，直到线程执行完成或超时。
  20. finished(): 在线程执行完成时发出信号。
  21. terminate(): 强制终止线程的执行，不推荐使用，可能导致资源泄漏和未定义行为。
  22. isRunning(): 判断线程是否正在运行。
  23. currentThreadId(): 返回当前线程的ID。
  24. yieldCurrentThread(): 释放当前线程的时间片，允许其他线程执行。
  25. msleep(): 让当前线程休眠指定的毫秒数。
复制代码
2 信号槽

  1. // 和调用 exit() 效果是一样的
  2. // 调用这个函数之后, 再调用 wait() 函数
  3. [slot] void QThread::quit();
  4. // 启动子线程
  5. [slot] void QThread::start(Priority priority = InheritPriority);
  6. // 线程退出, 可能是会马上终止线程, 一般情况下不使用这个函数
  7. [slot] void QThread::terminate();
  9. // 线程中执行的任务完成了, 发出该信号
  10. // 任务函数中的处理逻辑执行完毕了
  11. [signal] void QThread::finished();
  12. // 开始工作之前发出这个信号, 一般不使用
  13. [signal] void QThread::started();
复制代码
3 静态函数
  1. // 返回一个指向管理当前执行线程的QThread的指针
  2. [static] QThread *QThread::currentThread();
  3. // 返回可以在系统上运行的理想线程数 == 和当前电脑的 CPU 核心数相同
  4. [static] int QThread::idealThreadCount();
  5. // 线程休眠函数
  6. [static] void QThread::msleep(unsigned long msecs);        // 单位: 毫秒
  7. [static] void QThread::sleep(unsigned long secs);        // 单位: 秒
  8. [static] void QThread::usleep(unsigned long usecs);        // 单位: 微秒
复制代码
4 重写函数

  1. // 子线程要处理什么任务, 需要写到 run() 中
  2. [virtual protected] void QThread::run();
复制代码
2种线程使用方式

使用 QThread 时的一个常见误区。


  • QThread 实例存在于实例化它的旧线程中:

    • 当您创建一个 QThread 对象时,该对象会存在于创建它的线程中,而不是在新创建的线程中。
    • 这意味着,您调用 QThread 对象的方法和槽时,实际上是在创建该对象的线程中实行的,而不是在新创建的工作线程中。

  • 在新线程中调用槽:

    • 如果您盼望在新创建的工作线程中实行某些操作,比如调用槽函数,就不能直接将这些槽函数定义在 QThread 子类中。
    • 由于 QThread 子类的方法和槽都会在创建该对象的线程中实行,而不是在工作线程中实行。

  • 使用工作对象方法:

    • 为了在新创建的工作线程中实行操作,您需要定义一个独立的工作对象类,并将全部的工作逻辑封装在该类中。
    • 在工作线程中,您可以创建这个工作对象的实例,并在该实例上调用方法来实行工作。

使用 QThread 时需要注意区分线程的概念。QThread 对象本身存在于创建它的线程中,而不是在新创建的工作线程中。如果您盼望在工作线程中实行操作,需要使用独立的工作对象,而不是直接在 QThread 子类中实现。这样可以确保在正确的线程中实行您的工作逻辑。 
简化：在这里先记取
1.new QThread 是在当前代码位置创建出来的
2.线程调用槽函数是有坑点的。
3.最好使用工作对象方法

线程和工作逻辑



  • 主线程和子线程实行的顺序不确定，偶然主线程在前，偶然子线程在前。
  • 只有run()函数运行在子线程中，run调用子函数则在子线程调用子函数。
  1. class WorkerThread : public QThread
  2. {
  3.     Q_OBJECT
  5. public:
  6.     void run() override  //子线程工作函数
  7.     {
  8.         // 在新线程中执行耗时任务
  9.         for (int i = 0; i < 5; ++i)
  10.         {
  11.             qDebug() << "Worker thread doing work..." << i;
  12.             sleep(1);
  13.         }
  14.         emit finished();
  15.     }
  17. signals:
  18.     void finished();
  19. };
  21. int main(int argc, char *argv[])
  22. {
  23.     QCoreApplication a(argc, argv);
  25.     // 创建并启动工作线程
  26.     WorkerThread* workerThread = new WorkerThread;
  27.     QObject::connect(workerThread, &WorkerThread::finished, workerThread, &WorkerThread::deleteLater);
  28.     workerThread->start();
  32.      // 等待任务完成
  33.     workerThread->wait();
  35.     // 停止并退出事件循环
  36.     a.exit();
  37.     return a.exec();
  38. }
复制代码
这个例子演示了如何在一个全新的线程中实行耗时的工作任务。通过继承 QThread 并重写 run() 方法,我们可以在新线程中运行自定义的工作逻辑。这种方式与下列的例子有所不同,下列的例子是在工作对象中实行任务,而不是在 QThread 子类中。
线程和工作对象



  • 槽函数无论是线程的信号触发还是自定义信号触发，槽函数都在新线程里运行。
  • 成员函数和主函数运行在主线程当中。
  1. #include <QDebug>
  2. #include <QThread>
  4. class Worker : public QObject
  5. {
  6.     Q_OBJECT
  8. public:
  9.     Worker()
  10.     {
  11.     }
  13. public slots:
  14.     void doWork()
  15.     {
  16.         // 执行耗时的计算任务
  17.         for (int i = 0; i < 5; ++i)
  18.         {
  19.             qDebug() << "Worker thread doing work..." << i;
  20.             QThread::sleep(1);
  21.         }
  23.         // 计算完成后,发射 finished 信号
  24.         emit finished();
  25.     }
  27. signals:
  28.     void finished();
  29. };
  32. int main(int argc, char *argv[])
  33. {
  34.     QCoreApplication a(argc, argv);
  36.     // 创建工作线程
  37.     QThread* workerThread = new QThread;
  39.     // 创建工作对象实例,并将其移动到工作线程中
  40.     Worker* worker = new Worker;
  41.     worker->moveToThread(workerThread);//将其移动到工作线程中。这确保了 Worker 对象的所有操作都在工作线程中进行
  43.     // 连接信号和槽
  44.     QObject::connect(workerThread, &QThread::started, worker, &Worker::doWork);
  45.     QObject::connect(worker, &Worker::finished, workerThread, &QThread::quit);
  46.     //即使 main() 函数执行完毕,主线程退出,QThread 对象也不会立即被释放,而是会等待工作线程完成后再被删除。
  47.     QObject::connect(worker, &Worker::finished, worker, &Worker::deleteLater);
  48.     QObject::connect(workerThread, &QThread::finished, workerThread, &QThread::deleteLater);
  50.     // 启动工作线程
  51.     workerThread->start();
  53.     return a.exec();
  54. }
复制代码
在这个例子中,QThread 对象代表了实际的工作线程,而 Worker 对象包罗了实际的工作逻辑。这样,我们就可以在工作线程中实行耗时的计算任务,而不会阻塞主线程。当任务完成时,Worker 对象会发射 finished 信号,从而触发工作线程退出和对象整理。 
代码运行示例

重写线程类：work.h

  1. #ifndef WORK_H
  2. #define WORK_H
  4. #include<QDebug>
  5. #include<QThread>
  6. #include<QMutex>
  7. #include<QSemaphore>
  8. class work : public QThread
  9. {
  10.     Q_OBJECT
  12. public:
  13.     work();
  14.     virtual ~work(); // 添加虚拟析构函数
  17. public:
  18.     void run() override;
  20.     void stopAndWait() {  //完美退出
  21.         m_running = false;
  22.         wait();     //等待任务完成
  23.         exit();  //停止并退出事件循环
  24.         qDebug() << "stopAndWait";
  26.         deleteLater(); //安全地删除 QObject 及其子类对象 异步地删除对象,而不是立即删除 注意：该函数是线程安全,多次调用该函数是安全的；
  27.     }
  29. private:
  30.     bool m_running; //完美退出
  31.     static uint16_t index;
  32. };
  34. #endif // WORK_H
  37. #include "work.h"
  39. uint16_t work::index = 1;
  41. work::work()
  42. {
  43.     // 构造函数实现
  44.     m_running=true;
  45. }
  47. work::~work()
  48. {
  49.     // 虚拟析构函数实现
  50. }
  51. void work::run() {
  52.     // 执行耗时工作
  53.     while (m_running) {
  54.         qDebug() << "Worker thread doing run..." << this->index++;
  55.         sleep(1);
  56.     }
  57.     qDebug() << "Worker thread exiting.";
  58. }
复制代码
工作对象类

workthread.h
  1. #ifndef WORKTHREAD2_H
  2. #define WORKTHREAD2_H
  3. #include<QDebug>
  4. #include<QThread>
  7. class workthread2 : public QObject
  8. {
  9.     Q_OBJECT
  10. public:
  11.     workthread2()=default;
  12.     ~workthread2()=default;
  13. public:
  14.     enum class ThreadState { Idle, Running, Finished };
  15.     Q_ENUM(ThreadState)
  17. signals:
  18.     void finished();
  20. public slots:
  21.     void doWork()
  22.     {
  23.         // 执行耗时的计算任务
  24.         for (int i = 0; i < 5; ++i)
  25.         {
  26.             qDebug() << "Worker thread doing work..." << i;
  27.             QThread::sleep(1);
  28.         }
  30.         // 计算完成后,发射 finished 信号
  31.         emit finished();
  32.     }
  35. };
  37. #endif // WORKTHREAD2_H
复制代码
main函数

  1. #include <QCoreApplication>
  3. #include"work.h"
  4. #include<workthread2.h>
  5. #include<QTimer>
  6. void qtThread_text(){
  7.     //第一种 继承重写run方法
  8.     QVector<work*> workerThreads;
  9.     // 创建并启动工作线程
  10.     for(int i=0;i<3;i++)
  11.     {
  12.         workerThreads.append(new work());
  13.     }
  14.     for(int i=0;i<3;i++)
  15.     {
  16.         workerThreads.at(i)->start();
  17.     }
  20.     // 等待一段时间后,通知线程退出
  21.     QThread::sleep(1);
  22.     for(work* data :workerThreads){
  23.         data->stopAndWait();
  24.         //data->deleteLater();
  25.     }
  26.     //    for(int i=0;i<3;i++)
  27.     //    {
  28.     //        workerthread[i]->wait();
  29.     //        workerthread[i]->terminate(); //发送线程终止信号
  30.     //    }
  33.     //第2种 使用对象模式 注意此模式是在当前线程运行
  34.     QThread* newthread= new QThread;
  35.     QThread* newthread2= new QThread;
  36.     // 启动工作线程 一个对象只能隶属于一个线程
  39.     workthread2* work2 = new workthread2;
  40.     workthread2* work2_2 = new workthread2;
  41.     work2->moveToThread(newthread);
  42.     work2_2->moveToThread(newthread2);
  43.     // 启动工作线程
  44.    newthread->start();
  45.    newthread2->start();
  47.    // 连接信号和槽
  48.     QObject::connect(newthread, &QThread::started, work2, &workthread2::doWork);
  49.     QObject::connect(work2, &workthread2::finished, newthread, &QThread::quit);
  50.     QObject::connect(work2, &workthread2::finished, work2, &workthread2::deleteLater);
  51.     QObject::connect(newthread, &QThread::finished, newthread, &QThread::deleteLater);
  53.     QObject::connect(newthread2, &QThread::started, work2_2, &workthread2::doWork);
  54.     QObject::connect(work2_2, &workthread2::finished, newthread2, &QThread::quit);
  55.     QObject::connect(work2_2, &workthread2::finished, work2_2, &workthread2::deleteLater);
  56.     QObject::connect(newthread2, &QThread::finished, newthread2, &QThread::deleteLater);
  58.     newthread->start();
  59.     newthread2->start();
  60. /*
  61.     newthread->wait();
  62.     newthread->exit();
  63.     当 newthread->wait() 被调用时,它会阻塞当前线程(即主线程)直到 newthread 线程退出。然后 newthread->exit() 被调用,停止并退出了事件循环。
  64.     qDebug() << "a.exec()"; 这行代码就不会被执行。
  65. */
  67.     // 等待线程完成并退出事件循环
  68.    newthread->wait();
  69.    newthread2->wait();
  71.    newthread->exit();
  72.    newthread2->exit();
  73. }
  74. int main(int argc, char *argv[])
  75. {
  76.     QCoreApplication a(argc, argv);
  77.     qtThread_text();
  79.     // 手动调用 a.exec()
  80.     qDebug() << "a.exec()";
  81.     return a.exec(); //开启Qt 的事件循环
  82. }
复制代码
运行效果


总结

上述提到的两种使用 QThread 的方式有以下几点主要区别: (第一种重写 第二种movetoThread)

  • 线程的创建方式
  • ***线程与工作对象的关系:

    • 在第一种方式中,线程和工作逻辑是耦合在一起的,由于工作逻辑直接在 QThread 的子类中实现。
    • 在第二种方式中,线程和工作对象是解耦的,工作逻辑被封装在独立的 Worker 对象中。

  • ***信号槽的实行位置:

    • move版本槽函数无论是线程的信号触发还是自定义信号触发，槽函数都在新线程里运行。
    • 重写版本信号槽是在主线程实行。

  • 线程安全性:

    • 在第二种方式中,由于工作对象是在工作线程中运行的,因此不需要担心线程安全性题目。
    • 在第一种方式中,如果在 QThread 的子类中访问了共享资源,就需要特别注意线程安全性。

  • 机动性和可重用性:
    重写机动性和可重用性低，move版本低耦合
  • 错误处理:

    • 在第二种方式中,可以更容易地在工作对象中捕获和处理错误,由于工作逻辑被封装在了独立的对象中。
    • 在第一种方式中,错误处理可能更加困难,由于工作逻辑和线程紧耦合在一起。

总的来说,主要区别在于代码结构和筹划模式,而不是线程的创建方式。无论接纳哪种方式,都是在主线程中创建和启动了工作线程。由于4.8更新了movetothread版本，既然是更新，阐明这种方法更好，建议大家在使用时接纳movetothread版本

参考文献：

Qt 线程中QThread的使用_qt qthread-CSDN博客
QThread 类 | Qt 核心 5.15.17 --- QThread Class | Qt Core 5.15.17
一文搞定之Qt多线程(QThread、moveToThread)_qthread movetothread-CSDN博客
最后附上源代码链接
对您有帮助的话，帮忙点个star

36-qthread-qmutex-qsemaphore · jbjnb/Qt demo - 码云 - 开源中国 (gitee.com)

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

正序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

丝

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表