[Qt]一个简单的Qt Widget多线程处理图像的例子

最新推荐文章于 2024-07-24 00:10:40 发布
最新推荐文章于 2024-07-24 00:10:40 发布
阅读量9.7k 收藏 26
点赞数 2
分类专栏： linux/QT

最近开始学习Qt。发现Qt的资料比起不好用的MFC实在是不多啊。今天刚好看到了Qt多线程，就写了个小例子放出来，希望能帮到跟我一样的初学者。

简单讲下。程序就两个界面。一个主要的QDialog，一个显示图像的自定义控件MyPicBox 。还有就是动态创建了一个QMainWindow，因为我要用QMainWindow::setCentralWidget来放置MyPicBox。
软件的作用是多线程实现图像的灰度化（因为这个足够简单，毕竟这个DEMO的重点不是讲图像处理），然后把处理结果显示出来。大概呢，就是下面这个样子。
不要问我照片里的人是谁。哈哈哈哈~~~~
[Qt]一个简单的Qt Widget多线程处理图像的例子 - code monster - 仗剑天下的博客
  
好了，我还是直接上代码吧。一切都在注释中：
首先是主对话框类.h（窗口标题是”选择图片“那个）： 
#pragma once
#include <QDialog>
#include <QImage>
#include "my_thread.h"
namespace Ui {
class MainDialog;
}
/**
 * @brief The MainDialog class
 * 主对话框类
 */
class MainDialog : public QDialog
{
    Q_OBJECT
public:
    explicit MainDialog(QWidget *parent = 0);
    ~MainDialog();
private slots:
    void on_pushButton_selectImage_clicked();
    void on_pushButton_toGrayImage_clicked();
    /**
     * @brief showImageInNewWindow 接收由子线程信号传来的QImage指针，并显示这个QImage
     * @param image
     */
    void showImageInNewWindow(QImage* image);
    /**
     * @brief closeThread 如果关闭Dialog的时候子线程还没有结束，应该手动结束它
     */
    void closeThread();
    /**
     * @brief SetProgress 设置对话框中的进度条进度
     * @param max 进度条最大值
     * @param value 当前值
     */
    void SetProgress(int max,int value);
private:
    Ui::MainDialog *ui;
    MyImageProcessThread* thread;
    QString imagePath;
    //进度条的最大值是否已经设置，如果已经设置了就不需要重新设置了，不然UI会反复出现进度条增长
    bool hasProgressBarMaxSet;
    QImage* imageSelected;//原来的图片(无视，这里根本没用它)
    QImage* imageAfterProceess;//处理后的图片(无视，这里根本没用它)
};
然后是主对话框.cpp
#include <QDebug>
#include "my_thread.h"
#include "main_dialog.h"
#include "ui_maindialog.h"
#include "mypicbox.h"
#include <QFileDialog>
#include <QMainWindow>
MainDialog::MainDialog(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::MainDialog)
{
    ui->setupUi(this);
    ui->label_2->setVisible(false);
    ui->progressBar->setVisible(false);
    hasProgressBarMaxSet = false;
    this->thread = new MyImageProcessThread();
    //---------------为了方便显示，我固定了Dialog大小----------
    QSize size = this->size();
    this->setFixedSize(size);
    //------------------------------------------------------------
    connect(this,SIGNAL(destroyed()),this,SLOT(closeThread()));
    //在这里关联从图像处理线程发出的信号，然后用showImageInNewWindow来处理由信号传入的QImage指针
    connect(thread,SIGNAL(processFinished(QImage*)),this,SLOT(showImageInNewWindow(QImage*)));
    connect(thread,SIGNAL(processProgress(int,int)),this,SLOT(SetProgress(int,int)));
}
MainDialog::~MainDialog()
{
    delete ui;
}
void MainDialog::on_pushButton_selectImage_clicked()
{
    this->imagePath = QFileDialog::getOpenFileName();
    ui->lineEdit->setText(imagePath);
}
void MainDialog::on_pushButton_toGrayImage_clicked()
{
    if(this->imagePath.isEmpty())
    {
        qDebug()<<"imagePath is  empty !!!";
        return ;
    }
    qDebug()<<"Start a new thread !!!";
    //由于子线程的创建是在Dialog的构造函数中进行的，
那个时候图像路径还没有指定
     this->thread->setImagePath(this->imagePath);
     this->thread->start();
}

void MainDialog::showImageInNewWindow(QImage *image)
{
    QMainWindow*  picWindow = new QMainWindow(this);
    MyPicBox* picBox = new MyPicBox(image,picWindow);
    picWindow->setCentralWidget(picBox);
    //为了防止图像过大，这里对图像显示窗口的大小做了点儿限制
    if(image->width() > 600)
    {
	//压缩系数,以600宽度为准
        double scaleCoefficient =600.0/image->width();
	//重新设定窗口大小
        picWindow->resize(600,scaleCoefficient*image->height());
    }
    else if(image->height() > 800)
    {
        //压缩系数,以800高度为准
	double scaleCoefficient =800.0/image->height();
	//重新设定窗口大小
        picWindow->resize( scaleCoefficient*image->width(),800);
    }
   else
       picWindow->resize(image->width(),image->height());
   //----------------------------------------------------
    picWindow->setWindowTitle("处理结果");
    picWindow->move(100,100);//调整一下窗口位置
    picWindow->show();
}

void MainDialog::closeThread()
{
    if(this->thread->isRunning())
    {
        this->thread->terminate();
        qDebug()<<"Thread has been terminated !!!";
    }
}
void MainDialog::SetProgress(int max, int value)
{
  ui->label_2->setVisible(true);
  ui->progressBar->setVisible(true);
  if(!hasProgressBarMaxSet)
  {
      ui->progressBar->setMaximum(max);
      hasProgressBarMaxSet = true;
  }
  ui->progressBar->setValue(value);
}

 
 
 
  ---------------------------------------------------------我是分隔符------------------------------------------------------------------------------------------------ 
 
 图像处理线程类.h： 

 

 
 
#pragma once
#include <QThread>
#include <QImage>
#include <QObject>
/**
 * @brief The MyImageProcessThread class
 * 图像处理的线程类，需要传入一个QImage图像指针
 * 同时包含两个自定义信号
 */
class MyImageProcessThread : public QThread
{
    /*
     * 注意：必须添加Q_OBJECT宏使其能够应用Qt的信号槽机制，
     *不然你就没法更新UI界面啦
     */
    Q_OBJECT
public:
    MyImageProcessThread();
    MyImageProcessThread(QString& imagePath,QObject* parent = 0);
    ~MyImageProcessThread();
    /*
     *继承QThread类之后，必须实现 run() 函数。
     *在run函数中实现你要在子线程中运行的代码
     */
    virtual void run();
    QString getImagePath() const;
    void setImagePath(const QString &value);
signals:
    //自定义信号。表示处理结束了。
    //可以百度“自定义信号”查找更多内容
    void processFinished(QImage*);
    //自定义信号。用以表示算法进度。
    //maxValue表示进度最大值，progress表示当前值
    void processProgress(int maxValue,int progress);
private:
    QString imagePath;
    QImage* result;
};
 然后是图像处理线程类.cpp 

 

 
 
#pragma once
#include "my_thread.h"
#include <QDebug>
#include <QTime>
MyImageProcessThread::MyImageProcessThread()
{
}
MyImageProcessThread::MyImageProcessThread(QString &imagePath, QObject *parent):QThread(parent)
{
    if(!imagePath.isEmpty())
        this->imagePath = imagePath;
}
MyImageProcessThread::~MyImageProcessThread()
{
}
void MyImageProcessThread::run()
{
    //这里我们记录下当前系统时间，统计一下算法耗时
    QTime timer = QTime::currentTime();
    timer.start();//开始计时
   if(this->imagePath.isEmpty())
   {
        qDebug()<<"path is NULL";
       return;
    }
   //摘自某博文:
   //采用bits()方法的到的数据data中像素的组织形式应为ARGB，
   //但实际调试中发现，每个像素中从字节从低到高依次是BGRA，方向刚好反过来。
   QImage* image = new QImage(imagePath);
   unsigned char* data = image->bits();//取得QImage对应的byte数组
   int byteCount = image->byteCount();//byte数组长度
   unsigned char* dataNew = new unsigned char[byteCount];//再申请一个一样大小的数组
   int counter = 0;//循环记录处理了多少个字节
   int hasDone = 0;//记录累计处理的百分比
   for(int i  = 0 ; i <byteCount ; i+=4)
    {
        unsigned char grayByte = (unsigned char)(0.30 *data[ i+2] +0.59*data[ i + 1]+0.11*data[ i]);
        dataNew[i]     = grayByte;
        dataNew[i+1] = grayByte;
        dataNew[i+2] = grayByte;
        dataNew[i+3] = data[i+3];
        //每处理到字节总量的1/100就更新一次UI
        if(counter == (int)(byteCount/100))
          {
            counter = 0;
            hasDone +=1;
            emit processProgress(100,hasDone);
            this->sleep(1);//这里我让线程休眠1秒，不然进度条瞬间就走完了。
            }
        else
           counter++;
    }
   emit processProgress(100,100);
   //生成新的QImage
   int w = image->width();
   int h = image->height();
   QImage* newImage = new QImage(dataNew,w,h,image->format());
  //取得算法结束的时间
  int timeTaken = timer.elapsed();
  qDebug()<<"Processing takes "<<timeTaken<<"ms"<<endl;
  //处理完毕后，我们就可以发射信号让UI线程接收处理后的图像了
   qDebug()<<"process has been finished.Get ready for emitting the signal !!! ";
   emit processFinished(newImage);
}
QString MyImageProcessThread::getImagePath() const
{
    return imagePath;
}
void MyImageProcessThread::setImagePath(const QString &value)
{
    imagePath = value;
}
 ---------------------------------------------------------我是分隔符------------------------------------------------------------------------------------------------ 

 


  显示图像的QWidget.h 

 

 
 
#pragma once
#include <QWidget>
#include <QImage>
namespace Ui {
class MyPicBox;
}
/**
 * @brief The MyPicBox class
 * 用于绘制QImage的自定义QWidget。同样需要你传入一个QImage指针
 * 当需要显示图片时，这个类（也就是这个QWidget）会被装进一个QMianWindow。
 */
class MyPicBox : public QWidget
{
    Q_OBJECT
public:
    explicit MyPicBox(QWidget *parent = 0);
    explicit MyPicBox(QImage* image , QWidget *parent = 0);
    ~MyPicBox();
protected:
    //考虑到QLabel显示图像时的限制。我们这里直接把图像画出来。
    void paintEvent(QPaintEvent * event);
private:
    Ui::MyPicBox *ui;
    QImage* image;
};
 
 显示图像的QWidget.cpp 

 

 
 
#pragma once
#include "mypicbox.h"
#include "ui_mypicbox.h"
#include <QPainter>
#include <QRect>
#include <QDebug>
MyPicBox::MyPicBox(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::MyPicBox)
{
    ui->setupUi(this);
}
MyPicBox::MyPicBox(QImage *image, QWidget *parent):QWidget(parent),ui(new Ui::MyPicBox)
{
    ui->setupUi(this);
    if(image != NULL)
    {
       this->image = image;
    }
}
MyPicBox::~MyPicBox()
{
    delete ui;
    //记得要释放QImage对象
    if(this->image != NULL)
        delete this->image;
}
void MyPicBox::paintEvent(QPaintEvent *event)
{
    QPainter painter(this);
    QRect rect = this->geometry();
    painter.drawImage(rect,*(this->image));
}
 
 ---------------------------------------------------------我是分隔符------------------------------------------------------------------------------------------------ 

 


  当然，最后还有main.cpp我就不上了。默认啥样就啥样。 

 


  全部工程源码我放在网盘了,感兴趣的童鞋自己去下载吧。 

 

 
 http://pan.baidu.com/s/1hqEe1nA 

 


  网易这代码排版我也是醉了。 

 


  最后，再次希望能够帮到跟我一样的初学者~ 

 

 

 


 
 


 
 


 
 


 
 

from： http://powful1.blog.163.com/blog/static/5662321620152911372943/?newFollowBlog

                

        

        

    

  


    

      

        

            

              
                
                  imxiangzi
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
【OpenGL概念】QOpenGLWidget类详述--此文档基于Qt5.14.2

				
			

			

				

					gongdiwudu的专栏
				

				

					04-17
					
					3920
					
				

			

		

		

			
				
QOpenGLWidget提供了在Qt应用程序中显示集成OpenGL图形的功能。使用它非常简单：让您的类继承它，并像使用任何其他QWidget一样使用子类，除了您可以选择使用QPainter和标准OpenGL渲染命令之间的区别。

			
		

	



                

              
                



	

		

			

				
					
qt-opencv-multithreaded-1.21Qt结合OpenCV多线程图像处理

				
			

			

				

					04-04
				

			

		

		

			
				
Qt中利用OpenCV2.4.4多线程打开多摄像机
每个线程处理一个摄像机，从中拿出帧显示到主线程的Label控件上
模拟了一个16个摄像机的场景，有不开多线程和打开多线程的对比。
可以明显感觉到打开多线程后主界面不卡了。
只是个多线程的小例子，还有很多不足之处，有待各位完善。
注意：pro文件中的include和lib文件目录需要根据自己电脑上的情况重新配置

			
		

	



                


  
              

                


	

		

			

				
					
Qt+多线程实现单幅图像高斯、灰度、边缘处理，调用opencv库导入图片

				
			

			

				

					Sca_Lian的博客
				

				

					08-02
					
					2165
					
				

			

		

		

			
				
结合最近学的知识自己做了个小demo。可以实现对输入的图片进行图像处理，高斯模糊、灰度处理以及边缘检测，三种处理同时进行。思路借助OpenCv库，用Mat读取图片并输出展示在界面上，多线程进行图像处理。这里采用线程池的方法。点击输入图片按钮，弹出一个文件夹，可选取自己想处理的图片。点击开始处理按钮，成功实现同时输出三种处理图像。这里我选择了一张狗头的表清包。通过调试信息可以看到。...

			
		

	





	

		

			

				
					
QT--线程

					
最新发布

				
			

			

				

					m0_51830537的博客
				

				

					07-24
					
					2103
					
				

			

		

		

			
				
【代码】QT--线程。

			
		

	



		

			
		



	

		

			

				
					
Qt图像实时采集及边缘提取（多线程）

				
			

			

				

					lihaojia的博客
				

				

					01-14
					
					3769
					
				

			

		

		

			
				
Qt图像实时采集及边缘提取（多线程）
UML 图表
图像采集图像处理图像显示通过qq1进行生产者、消费者数据传输通过qq2进行生产者、消费者数据传输图像采集30ms、 图像显示30ms、图像处理10ms图像采集图像处理图像显示
这将产生一个流程图。:
链接长方形圆圆角长方形菱形

关于 Mermaid 语法，参考 [这儿][3],

流程图
图像采集线程
Created with Raphaël ...

			
		

	





	

		

			

				
					
QT封装相机的多线程采集(回调采集)

				
			

			

				

					邮箱：feboreigns001@163.com
				

				

					05-21
					
					3359
					
				

			

		

		

			
				
重点是思想和框架

把图像采集和图像处理放在线程中
 其中图像处理作为call_back


			
		

	





	

		

			

				
					
Qt - 多线程

				
			

			

				

					QtCompany的博客
				

				

					08-24
					
					335
					
				

			

		

		

			
				
随着芯片技术的发展，CPU 的处理速度越来越快，在保证流畅运行的情况下可以同时运行的进程越来越多。

			
		

	





	

		

			

				
					
qt 串口粘包_Qt Socket 收发图片——图像拆包、组包、粘包处理

				
			

			

				

					weixin_39685762的博客
				

				

					12-20
					
					824
					
				

			

		

		

			
				
之前给大家分享了一个使用python发图片数据、Qt server接收图片的Demo。之前的Demo用于传输小字节的图片是可以的，但如果是传输大的图片，使用socket无法一次完成发送该怎么办呢？本次和大家分享一个对大的图片拆包、组包、处理粘包的例子。程序平台：ubuntu 、 Qt 5.5.1为了对接收到的图像字节进行组包，我们需要对每包数据规定协议，协议如下图：每包数据前10个字节对应含义如下...

			
		

	





	

		

			

				
					
QT线程

				
			

			

				

					小青年儿
				

				

					03-23
					
					2009
					
				

			

		

		

			
				
线程基础

何谓线程?

线程与并行处理任务息息相关，就像进程一样。那么，线程与进程有什么区别呢？当你在电子表格上进行数据结算的时候，在相同的桌面上可能有一个播放器正在播放你最喜欢的歌曲。这是一个两个进程并行工作的例子：一个进程运行电子表格程序;另一个进程运行一个媒体播放器。这种情况最适合用多任务这个词来描述。进一步观察媒体播放器，你会发现在这个进程内，又存在并行的工作。当媒体播放器向音频

			
		

	





	

		

			

				
					
QT软件开发-基于FFMPEG设计视频播放器-GPU硬解、OpenGL渲染、解码音频完整例子（六）

				
			

			

				

					
				

				

					09-18
					
					2002
					
				

			

		

		

			
				
前面章节编写的例
子都是独立的，没有结合在一起，当前这篇文章是将前面的几个例子结合在一起，完成一个完整的播放器Demo开发。支持硬件加速解码视频帧、通过OpenGL渲染；解码音频帧、通过QAudioOutput播放音频。支持本地视频文件播放，支持流媒体地址播放。例如：rtmp、rtsp、hls、http等等协议。支持进度条跳转（实时直播流不支持的）、进度条显示，总时间显示，视频基本信息显示，基本上完成一个播放器的基础功能。

			
		

	





	

		

			

				
					
Qt多线程图片灰度处理

				
			

			

				

					08-31
				

			

		

		

			
				
Qt多线程图片灰度处理

			
		

	





	

		

			

				
					
Qt界面多线程opencv调用摄像头

				
			

			

				

					05-09
				

			

		

		

			
				
本代码是在qt平台下opencv利用多线程调用摄像头进行实时的视频显示在gui界面上，利用的时QThread的方法，是本人用了一年时间在维护的代码，需要的可以前来下载。当然我这也有qt上位机部分的代码，有需要的可以在评论区留言，我后续会上传。

			
		

	





	

		

			

				
					
（二）Qt多线程实现海康工业相机图像实时采集

					
热门推荐

				
			

			

				

					XCJandLL的博客
				

				

					12-31
					
					1万+
					
				

			

		

		

			
				
本文主要讲述了使用Qt多线程实现海康工业相机图像的采集，并在界面上将两个相机采集到的图像信息同时显示出来。

			
		

	





	

		

			

				
					
Qt：多线程学习（二）图像转点云

				
			

			

				

					累了就要打游戏
				

				

					12-06
					
					726
					
				

			

		

		

			
				
一、说明

个人记录，喷子绕道。

（1）线程类继承QThread，重写 run 函数。

（2）利用OpenCV读图像，利用LASlib写点云。每张图像对应一个点云。

（3）图像分辨率 = 4096 * 2080，一个点云文件有8519680个点。

（4）测试电脑：i5-3210M，8G内存，三星固态。内核数=2，逻辑处理器数=4。

（5）100张图像，1个线程用时181秒，2个线程用时123秒，3个线程用时96秒，4个线程用时99秒。

 

 

二、测试代码

分享给有需要的人，代码质...

			
		

	





	

		

			

				
					
Qt5.7 + OpenCV3.2开启多线程调用系统摄像头并实现视频录制与回放、图片截取与保存(二)摄像头画面显示与视频保存

				
			

			

				

					qq_34578785的博客
				

				

					11-20
					
					4562
					
				

			

		

		

			
				
在上一篇博客中，我们介绍了OpenCV中常用的类，并且实现了使用OpenCV加载本地的一张图片，本篇文章将讲解如何使用OpenCV调用系统摄像头，实现实时画面显示以及视频的存储与回放
事实上，视频的显示与图片显示原理一样，只不过视频是N多张图片叠放在一起的结果——显示摄像头画面时，使用VideoCapture捕捉摄像头画面，借助定时器每隔相同的时间在窗口中显示一帧；视频存储是将图片按照一定的频率压...

			
		

	





	

		

			

				
					
QT多线程采集摄像头数据处理显示(QVideoProbe+QCamera+QThread)

				
			

			

				

					
				

				

					03-26
					
					6854
					
				

			

		

		

			
				
一、环境介绍

操作系统介绍：ubuntu 18.04 、windows、Android

QT版本: 5.12.6

摄像头: USB摄像头、虚拟机挂载本机自带摄像头

二、功能介绍

在子线程里通过QVideoProbe捕获摄像头一帧数据，处理之后(加时间水印)，再通过信号/槽机制发送给主线程，在UI界面显示。

子线程方式采用moveToThread方式实现，因为需要用到QVideoPr...

			
		

	





	

		

			

				
					
视频监控开发文档

				
			

			

				

					Shengguiwei的专栏
				

				

					12-16
					
					1633
					
				

			

		

		

			
				
视频监控开发文档  作者：杰洲村的木棉  学校：广东工业大学    QQ:568109894                                                       源文来自http://luwenchao100.blog.hexun.com/23060023_d.html#        本文档是自己所整理的一份文档，部分是原创，还转贴了网

			
		

	





	

		

			

				
					
多线程保存图片，速度比原来提高百倍

				
			

			

				

					苏钟白的博客
				

				

					12-23
					
					4687
					
				

			

		

		

			
				
多线程保存图片提速

			
		

	





	

		

			

				
					
写一个qt的多线程例子

				
			

			

				

					09-07
				

			

		

		

			
				
### 回答1：

以下是一个使用 Qt 创建多线程应用程序的简单例子：#include <QtCore>class Worker : public QObject
{
    Q_OBJECTpublic slots:
    void doWork()
    {
        QString result;
        /* ... here is the expensive or blocking operation ... */
        emit resultReady(result);
    }signals:
    void resultReady(const QString &s);
};int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);    Worker *worker = new Worker;
    QThread *thread = new QThread;
    worker->moveToThread(thread);
    thread->start();    QObject::connect(worker, &Worker::resultReady,
        [](const QString &s){ qDebug() << s; });
    QMetaObject::invokeMethod(worker, "doWork", Qt::QueuedConnection);    return a.exec();
}  

### 回答2：
下面是一个简单的Qt多线程的例子：

```cpp
#include <QtWidgets>
#include <QtCore>

// 继承自 QObject 并且 Q_OBJECT 宏
class WorkerThread : public QObject
{
    Q_OBJECT

public:
    explicit WorkerThread(QObject *parent = nullptr) : QObject(parent) {}

public slots:
    // 在新线程中执行的耗时操作
    void doWork()
    {
        // 模拟耗时操作
        for (int i = 0; i < 1000000000; ++i) {}

        // 发射信号，通知主线程操作完成
        emit workDone();
    }

signals:
    // 信号，通知主线程操作完成
    void workDone();
};

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    // 创建一个新的线程
    QThread workerThread;

    // 创建一个 WorkerThread 的对象
    WorkerThread worker;

    // 将 WorkerThread 对象移动到新线程中
    worker.moveToThread(&workerThread);

    // 连接信号和槽，当 WorkerThread 发射 workDone 信号时，调用主线程的槽函数
    QObject::connect(&worker, SIGNAL(workDone()), qApp, SLOT(quit()), Qt::QueuedConnection);

    // 当新线程启动时，调用 worker 的 doWork 槽函数
    QObject::connect(&workerThread, SIGNAL(started()), &worker, SLOT(doWork()));

    // 当线程完成工作后，退出线程事件循环
    QObject::connect(&worker, SIGNAL(workDone()), &workerThread, SLOT(quit()));

    // 通过调用 QThread::start，启动新线程，并进入事件循环
    workerThread.start();

    return app.exec();
}
```

上面的例子中，我们创建了一个名为 WorkerThread 的类，继承自 QObject，并使用 Q_OBJECT 宏进行声明，以便使用 Qt 的信号和槽机制。WorkerThread 类中定义了一个 doWork() 槽函数，用来模拟一个耗时操作。当耗时操作完成后，通过发射 workDone 信号，通知主线程操作完成。

在主函数中，我们创建了一个新的线程 workerThread，然后创建一个 WorkerThread 对象 worker，并将其移动到 workerThread 线程中。然后我们通过连接信号和槽，将 workerThread 中的 started 信号与 worker 的 doWork 槽函数连接起来，以便在线程启动时调用 doWork()。还将 workerThread 中的 finished 信号与 workerThread 的 quit 槽函数连接，以便在线程完成工作后退出线程事件循环。

最后通过调用 workerThread.start() 启动线程，并运行 app.exec() 进入主线程的事件循环。当 worker 发射 workDone 信号时，会调用主线程的 quit() 槽函数退出事件循环，程序结束运行。  

### 回答3：
下面是一个使用Qt框架实现的一个简单的多线程例子：

```cpp
#include <QCoreApplication>
#include <QThread>
#include <QDebug>

// 子线程类
class WorkerThread : public QThread
{
public:
    void run() override
    {
        qDebug() << "子线程开始执行";

        // 模拟耗时操作
        for (int i = 0; i < 5; i++) {
            // 每次休眠1秒
            sleep(1);
            qDebug() << "子线程执行中...";
        }

        qDebug() << "子线程执行完成";
    }
};

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

    qDebug() << "主线程开始执行";

    // 创建子线程对象
    WorkerThread worker;
    // 启动子线程
    worker.start();

    // 模拟主线程执行其他任务
    for (int i = 0; i < 3; i++) {
        // 每次休眠1秒
        sleep(1);
        qDebug() << "主线程执行中...";
    }

    qDebug() << "主线程执行完成";

    // 等待子线程执行完毕
    worker.wait();

    return a.exec();
}
```

这个例子创建了一个继承自QThread的子线程类WorkerThread，重写了run方法，在run方法中模拟了一个耗时操作。在主函数main中，首先创建了一个WorkerThread对象，并调用start方法启动子线程。然后主线程执行其他任务，最后使用wait方法等待子线程执行完毕。运行程序，可以观察到主线程和子线程的执行顺序和交替执行的效果。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值