QT线程 （8）

于 2024-02-03 16:33:42 发布
阅读量1k 收藏 23
点赞数 22
CC 4.0 BY-SA版权
分类专栏： QT 文章标签： qt C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41328470/article/details/136005536
本文详细介绍了QT中的线程使用，包括为何需要线程、QT4和QT5线程的区别、如何创建和管理线程、处理复杂数据的线程使用、退出线程的方法、connect的队列与直接方式以及线程内操作UI的注意事项。

QT的线程

文章目录

1、为什么要用线程？

看如下的dome:
ui的界面如下：
在这里插入图片描述
mywidget.h

#include <QWidget>
#include <QTimer>

QT_BEGIN_NAMESPACE
namespace Ui { class MyWidget; }
QT_END_NAMESPACE

class MyWidget : public QWidget
{
    Q_OBJECT

public:
    MyWidget(QWidget *parent = nullptr);
    ~MyWidget();
    QTimer *ptime;
private slots:
    void on_pushButton_clicked();
    void TimeDealSlot(void);

private:
    Ui::MyWidget *ui;
};

mywidget.cpp

#include "mywidget.h"
#include "ui_mywidget.h"
#include <QThread>

MyWidget::MyWidget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::MyWidget)
{
    ui->setupUi(this);
    ptime = new QTimer(this);

    connect(ptime, &QTimer::timeout, this, &MyWidget::TimeDealSlot);

}

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

void MyWidget::TimeDealSlot(void)
{
    static int i = 0;
    i++;
    ui->lcdNumber->display(i);
}

void MyWidget::on_pushButton_clicked()
{
    /* 启动定时器 */
    ptime->start(1000);
    /* 这个6s的延时当做是很复杂的数据处理 */
    QThread::sleep(6);

}

按下开始按钮启动定时器然后lcdNumber每隔一秒加1显示。但是后面有6s的延时的操作。其结果并不是我们想着这样。
真实的结果是6s执行完后lcdNumber每隔一秒才加1显示。因为在6s的延时时。都在处理这个延时。其它事情没法处理。
只能一件一件做完。当然如果每件事情都不是很复杂那也不会有影响。但这个复杂的6s延时是会有影响的。所以对于很复杂的
数据处理就需要另外开启一个线程。让这个线程来处理。
线程的优势：
在这里插入图片描述
多线程程序有以下几个特点：
在这里插入图片描述

2、QT线程

1. QT4线程

  1. 定义一个类继承与QThread。
  2. 在类里面重写void run()的虚函数(这个run就是线程处理函数并且run的访问限定符是protected。
  3. start()启动线程函数run。注意不能直接调用run()函数。
  4. 线程的退出Thread->quit() pThread->wait();
    模拟的流程如下：
    在这里插入图片描述
    mywidget.h
#include <QWidget>
#include <QTimer>
#include "mythread.h"
QT_BEGIN_NAMESPACE
namespace Ui { class MyWidget; }
QT_END_NAMESPACE
class MyWidget : public QWidget
{
    Q_OBJECT
public:
    MyWidget(QWidget *parent = nullptr);
    ~MyWidget();
    QTimer *ptime;
    Mythread *pThread;
private slots:
    void on_pushButton_clicked();
    void TimeDealSlot(void);
    void WidgetSlot(void);
private:
    Ui::MyWidget *ui;
};

mywidget.cpp

#include "mywidget.h"
#include "ui_mywidget.h"
#include <QThread>

MyWidget::MyWidget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::MyWidget)
{
    ui->setupUi(this);
    ptime = new QTimer(this);
    pThread = new Mythread(this);

    /* 定时器溢出信号timeout */
    connect(ptime, &QTimer::timeout, this, &MyWidget::TimeDealSlot);

    /* 当按窗口右上角x时，窗口触发destroyed()信号 */
    connect(this, &MyWidget::destroyed, this, &MyWidget::WidgetSlot);

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

void MyWidget::TimeDealSlot(void)
{
    static int i = 0;
    i++;
    ui->lcdNumber->display(i);
}
void MyWidget::WidgetSlot(void)
{
    /* 停止线程 */
    pThread->quit();
    /* 等待线程处理完手头动作 */
    pThread->wait();
}
void MyWidget::on_pushButton_clicked()
{
    /* 如果定时器没有工作 */
    if(ptime->isActive() == false) {
        /* 启动定时器 */
        ptime->start(1000);
    }
    /* 启动线程 不能直接调run函数 */
    pThread->start();
}

mythread.h

#include <QThread>
class Mythread : public QThread
{
    Q_OBJECT
public:
    explicit Mythread(QObject *parent = nullptr);

protected:
    //QThread的虚函数
    //线程处理函数
    //不能直接调用，通过start()间接调用
    void run();
signals:

};

mythread.cpp

#include "mythread.h"

Mythread::Mythread(QObject *parent)
    : QThread{parent}
{

}

void Mythread::run()
{
    /* 这个6s的延时当做是很复杂的数据处理 */
    QThread::sleep(6);
}

当开启一个线程并且把这个延时放到线程里处理。按下开始按钮启动定时器然后lcdNumber每隔一秒加1显示。这样就不会有影响。

1. QT5线程在这里插入图片描述

ui的界面
在这里插入图片描述

  1. 创建一个类继承与QObject
  2. 在类中定义一个线程处理函数（有且只有一个）
#include <QObject>

class mythread : public QObject
{
    Q_OBJECT
public:
    explicit mythread(QObject *parent = nullptr);
    /* 自定义线程处理函数 */
    void ThreadDeal(void);
};
  1. 在主线程里定义自定义线程与 子线程。并且自定义线程不能指定父对象。指定了会报一个错误。
QThread *pThread; /* 子线程 */
mythread *pMyThread; /* 自定义线程 */
//动态分配空间，不能指定父对象
pMyThread = new mythread;
//创建子线程
pThread = new QThread(this);
  1. 把自定义线程加入到子线程。
    //把自定义线程加入到子线程中  子线程 与 自定义线程建立联系
    pMyThread->moveToThread(pThread);
  1. 启动子线程，但是没有启动线程处理函数
    //启动子线程，但是没有启动线程处理函数
   pThread->start();
  1. 在启动子线程后发送一个自定义信号。通过信号与槽去启动线程处理函数。直接调用启动是没有用的。
//只能通过 signal - slot 方式调用
emit startThread(); /* 发送信号 */
/* 接收信号去启动线程处理函数 */
connect(this, &MyWidget::startThread, pMyThread, &mythread::myTimeout);
  1. 线程退出
    pThread->quit();
    pThread->wait();

总体的流程：
在这里插入图片描述
mywidget.h

#include <QWidget>
#include <QThread>
#include "mythread.h"
#include <QTimer>

QT_BEGIN_NAMESPACE
namespace Ui { class MyWidget; }
QT_END_NAMESPACE

class MyWidget : public QWidget
{
    Q_OBJECT

public:
    MyWidget(QWidget *parent = nullptr);
    ~MyWidget();
    QThread *pThread; /* 子线程 */
    mythread *pMyThread; /* 自定义线程 */
    QTimer *ptime;

private slots:
    void on_pushButtonStart_clicked();
    void on_pushButtonStop_clicked();
    void WidgetSlot(void);
    void TimeDealSlot(void);

signals:
    void StartThreadDealSignal();

private:
    Ui::MyWidget *ui;
};

mywidget.cpp

#include "mywidget.h"
#include "ui_mywidget.h"

MyWidget::MyWidget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::MyWidget)
{
    ui->setupUi(this);

    ptime = new QTimer(this);

    /* 自定义线程 不能指定父对象 */
    pMyThread = new mythread;

    /* 创建子线程 */
    pThread = new QThread(this);

    /* 把自定义线程加入到子线程 */
    pMyThread->moveToThread(pThread);

    /* 定时器溢出信号timeout */
    connect(ptime, &QTimer::timeout, this, &MyWidget::TimeDealSlot);

    /* 当按窗口右上角x时，窗口触发destroyed()信号 */
    connect(this, &MyWidget::destroyed, this, &MyWidget::WidgetSlot);

    /* 信号与槽去调用线程处理函数 */
    connect(this, &MyWidget::StartThreadDealSignal, pMyThread, &mythread::ThreadDeal);
}

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

void MyWidget::TimeDealSlot(void)
{
    static int i = 0;
    i++;
    ui->lcdNumber->display(i);
}
void MyWidget::on_pushButtonStart_clicked()
{
    /* 线程启动已经开启就退出 */
    if(pThread->isRunning() == true) {
        return;
    }
    qDebug() << "主线程号：" << QThread::currentThread();
    /* 如果定时器没有工作 */
    if(ptime->isActive() == false) {
        /* 启动定时器 */
        ptime->start(1000);
    }

    /* 启动子线程 但并没有启动线程处理函数 */
    pThread->start();

    /* 发送StartThreadDealSignal信号启动线程处理函数 */
    emit StartThreadDealSignal();
}

void MyWidget::WidgetSlot(void)
{
    on_pushButtonStop_clicked();
    delete pMyThread;
}

void MyWidget::on_pushButtonStop_clicked()
{
    /* 线程启动已经停止就退出 */
    if(pThread->isRunning() == false) {
        return;
    }
    /* 停止线程 */
    pThread->quit();
    /* 等待线程处理完手头动作 */
    pThread->wait();
}

mythread.h

#include <QObject>

class mythread : public QObject
{
    Q_OBJECT
public:
    explicit mythread(QObject *parent = nullptr);
    /* 自定义线程处理函数 */
    void ThreadDeal(void);

signals:

};

mythread.cpp

#include "mythread.h"
#include<QThread>
#include<QDebug>
mythread::mythread(QObject *parent)
    : QObject{parent}
{

}

void mythread::ThreadDeal(void)
{
    /* 这个6s的延时当做是很复杂的数据处理 */
    QThread::sleep(6);
    qDebug() << "子线程号：" << QThread::currentThread();
}

3. QT5线程的退出

pThread->quit()是会等到线程手头的工作处理完才退出。但如果线程的工作处理不完。比如死循环。那怎么退出呢？

    /* 这个6s的延时当做是很复杂的数据处理 */
    while(1) {
        QThread::sleep(6);
        qDebug() << "子线程号：" << QThread::currentThread();
    }
  1. 强制退出
    用pThread->terminate()代替pThread->quit。但是这样可能会导致内存问题。强制退出风险很大。
  2. 在自定义类里定义一个标志位
    mythread.h
    void setThreadQuitFlag(int flag); /* 设置标志位函数 */
    int ThreadQuitFlag;  // 定义一个标志位

mythread.cpp

#include "mythread.h"
#include<QThread>
#include<QDebug>
mythread::mythread(QObject *parent)
    : QObject{parent}
{
    ThreadQuitFlag = false;
}

void mythread::ThreadDeal(void)
{
    /* 这个6s的延时当做是很复杂的数据处理 */
    while(1) {
        QThread::sleep(6);
        qDebug() << "子线程号：" << QThread::currentThread();
        if (ThreadQuitFlag == true) {
            break; // 退出线程
        }
    }

}
void mythread::setThreadQuitFlag(int flag)
{
    ThreadQuitFlag = flag;
}

在主线程里一开始启动线程设置标志为

pMyThread->setThreadQuitFlag(false);

在主线程里结束线程设置标志为true就可以退出线程

pMyThread->setThreadQuitFlag(true);

4. connect的第五个参数

只介绍队列与直接方式。多线程时才有意义。
如果是多线程，默认使用队列方式。
如果是单线程， 默认使用直接方式。
队列: 槽函数所在的线程和接收者一样。
直接：槽函数所在线程和发送者一样。

1. 直接方式

在如上QT5线程的dome中设置第五个参数 Qt::DirectConnection

    /* 信号与槽去调用线程处理函数 */
    connect(this, &MyWidget::StartThreadDealSignal, pMyThread, &mythread::ThreadDeal, Qt::DirectConnection);

在这里插入图片描述
槽函数所在线程和发送者（主窗口）一样。

2. 队列方式

在如上QT5线程的dome中设置第五个参数 Qt::DirectConnection

    /* 信号与槽去调用线程处理函数 */
    connect(this, &MyWidget::StartThreadDealSignal, pMyThread, &mythread::ThreadDeal, Qt::QueuedConnection);

在这里插入图片描述
队列: 槽函数所在的线程和接收者(子线程）一样。

3、QT线程绘制QImage图片然后给到主线程显示刷新。

具体的流程：
1.点击绘图按钮调用线程处理函数
2. 线程里绘图图片但是不显示。绘制一次刷新一次。发送图片给主线程
3. 主线程拿到子线程的图片。在主窗口刷新显示。
伪代码如下：
在这里插入图片描述
注意：QImage才能在线程里绘图。
ui界面如下：就一个按钮
在这里插入图片描述

widget.h

#include <QWidget>
#include "mythread.h"
#include <QThread>
#include <QImage>

namespace Ui {
class Widget;
}

class Widget : public QWidget
{
    Q_OBJECT

public:
    explicit Widget(QWidget *parent = 0);
    ~Widget();
    QTimer *pTime;
    //重写绘图事件
    void paintEvent(QPaintEvent *);
public slots:
    void getImage(QImage); //槽函数
    void dealClose(); //窗口关闭槽函数

private:
    Ui::Widget *ui;
    QImage image;
    MyThread *myT; //自定义线程对象
    QThread *thread; //子线程
};

widget.cpp

#include "widget.h"
#include "ui_widget.h"
#include <QPainter>
#include <QThread>

Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    ui->setupUi(this);
    this->resize(600,600);

    //自定义类对象，分配空间，不可以指定父对象
    myT = new MyThread;

    //创建子线程
    thread = new QThread(this);

    //把自定义模块添加到子线程
    myT->moveToThread(thread);

    //启动子线程，但是，并没有启动线程处理函数
    thread->start();

    //线程处理函数，必须通过signal - slot 调用
    connect(ui->pushButton, &QPushButton::pressed, myT, &MyThread::drawImage);
    connect(myT, &MyThread::updateImage, this, &Widget::getImage);

    connect(this, &Widget::destroyed, this, &Widget::dealClose);

}

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

void Widget::dealClose()
{
    //退出子线程
    thread->quit();
    //回收资源
    thread->wait();
    delete myT;

}

void Widget::getImage(QImage temp)
{
    image = temp;
    update(); //更新窗口，间接调用paintEvent()
}

void Widget::paintEvent(QPaintEvent *)
{
    QPainter p(this); //创建画家，指定绘图设备为窗口
    p.drawImage(50, 50, image);
}

mythread.h

#include <QObject>
#include <QImage>

class MyThread : public QObject
{
    Q_OBJECT
public:
    explicit MyThread(QObject *parent = 0);

    //线程处理函数
    void drawImage();

signals:
    void updateImage(QImage temp);

public slots:
};

mythread.cpp

#include "mythread.h"
#include <QPainter>
#include <QPen>
#include <QBrush>
#include <QImage>
#include <QRandomGenerator>
MyThread::MyThread(QObject *parent) : QObject(parent)
{
}
void MyThread::drawImage()
{
    //定义QImage绘图设备
    QImage image(500, 500, QImage::Format_ARGB32); // QImage::Format_ARGB32透明的颜色
    //定义画家，指定绘图设备
    QPainter p(&image);
    //定义画笔对象
    QPen pen;
    pen.setWidth(5); //设置宽度
    //把画笔交给画家
    p.setPen(pen);

    //定义画刷
    QBrush brush;
    brush.setStyle(Qt::SolidPattern); //设置样式
    brush.setColor(QColor(QRandomGenerator::global()->bounded(0,255),QRandomGenerator::global()->bounded(0,255),
                          QRandomGenerator::global()->bounded(0,255))); //随机设置颜色
    //把画刷交给画家
    p.setBrush(brush);
    //定义点
    QPoint a[] =
    {
       QPoint(QRandomGenerator::global()->bounded(0,500), QRandomGenerator::global()->bounded(0,500)),
       QPoint(QRandomGenerator::global()->bounded(0,500), QRandomGenerator::global()->bounded(0,500)),
       QPoint(QRandomGenerator::global()->bounded(0,500), QRandomGenerator::global()->bounded(0,500)),
       QPoint(QRandomGenerator::global()->bounded(0,500), QRandomGenerator::global()->bounded(0,500)),
       QPoint(QRandomGenerator::global()->bounded(0,500), QRandomGenerator::global()->bounded(0,500)),
       QPoint(QRandomGenerator::global()->bounded(0,500), QRandomGenerator::global()->bounded(0,500))
    };

    /* 绘制多边形 */
    p.drawPolygon(a, sizeof(a)/sizeof(a[0]));
    //通过信号发送图片
    emit updateImage(image);
}

4、多线程使用过程中注意事项

需要移动到子线程中处理的模块类，创建的对象的时候不能指定父对象。但在关闭窗口时要记得释放。

    //自定义类对象，分配空间，不可以指定父对象
    myT = new MyThread;

线程不能操作UI对象（从Qwidget直接或间接派生的窗口对象）

#include "mythread.h"
#include<QThread>
#include<QDebug>
#include<QMessageBox>
mythread::mythread(QObject *parent)
    : QObject{parent}
{
    ThreadQuitFlag = false;
}
void mythread::ThreadDeal(void)
{
    /* 这个6s的延时当做是很复杂的数据处理 */
    while(1) {
        QThread::sleep(6);
        qDebug() << "子线程号：" << QThread::currentThread();
        if (ThreadQuitFlag == true) {
            break; // 退出线程
        }

        /* 在线程处理函数里操作UI对象 */
        QMessageBox::about(NULL,"关于","在线程处理函数内部不能操作图形界面");
    }

}

QMessageBox::about(NULL,“关于”,“在线程处理函数内部不能操作图形界面”)
这样会导致程序崩掉。
在这里插入图片描述
在线程处理函数内部不能操作图形界面。只能是纯数据处理。

5.总结

主要介绍QT的线程的两种用法。connect的第五个参数 。以及线程退pThread->terminate()与pThread->quit函数不一样。以及用pThread->quit。如果线程退不出来(死循环）用标志位来退出。还有线程里不能操作图形界面。

Qt4 http多线程程序
u010701590的专栏
04-11 1011
Qt4的多线程使用方法比较特殊，也使得编写多线程程序变的很简单，yo
[转载]QT编写多线程TCP文件接收服务器
zplove003的专栏
10-27 3475
因为项目需要，需要跨平台编写网络传输程序。 目标： 用户端：linux（arm平台），完成文件的传输 服务器：windows ，使用多线程的文件的接收 实现无线的文件传输功能 用户端程序，用标准的socket完成文件传输的功能，代码如下： 1: // Linux下网络编程，客户端程序代码 2: //程序运行参数： 3: // ./client IPADD
Qt4_多线程
qq_36314864的博客
06-13 282
多线程 .在多线程应用程序中，图形用户界面运行于它自己的线程中，而另外的事件处理过程则会发生在一个或多个其他线程中。这样做之后，即使在处理那些数据密集的事件时，应用程序也能对图形用户界面保持响应。 当在一个单处理器上运行时，多线程应用程序可能会比实现同样功能的单线程应用程序运行得更慢一些，无法体现出其优势。但在目前多处理器系统越来越普及的情况下，多线程应用程序可以在不同的处理器中同时执行多个线程，从而获得更好的总体性能。 ...
QT4中构建多线程的服务器
andylauren的专栏
08-16 932
而对于服务器来说，多线程的这个特性太有用了，因为多线程使得服务器可能同时响应多个客户端的请求，所以现在服务器大多采用多线程，所以才会造成我开始的误解。 不管是多线程，还是服务器，QT中已经封装好了特定的类，所以使用起来也很方便。 下面建立一个支持多线程、TCP的服务器。 首先建立一个服务器。新建一个类(Server)继承QT中的QTcpServer类即可。服务器的职责是监听端口。当监听到
QT4多线程编程
12-15 2183
最近正在学习QT编程，刚刚学习到多线程的章节，由于曾经有过MFC的使用经历，所以想到QT多线程是否也可以自定义事件。由于勾了一下，发现这篇文章更正《基于QT4的一个多线程工程实现》http://easons.blogbus.com/logs/30443107.html。于是也尝试测试了一下代码，发现居然有不少的代码错误，修改一番后终于能够运行了，但是跟踪却发现，事件发送后，代码根本就不能运行到My
Qt 线程串口读写串口数据
最新发布
11-13
在本文中，我们将深入探讨如何使用Qt框架进行线程化串口读写操作。Qt是一个功能强大的跨平台应用程序开发框架，特别适用于GUI编程。在处理串口通信时，由于串口操作通常涉及到I/O密集型任务，直接在主线程中进行可能...
QT多线程的实现方式：QThread run优雅的创建与退出QT多线程
09-13
与标准C++库中的std::thread不同，QThread有自己的事件循环，使得线程可以处理信号和槽，这使得在QT环境中使用多线程更加方便和灵活。 二、QThread的创建 创建QThread对象时，通常会继承QThread并重写run()方法。...
qt线程共享数据 信号和槽方式
03-15
Qt线程间共享数据主要有两种方式： 使用共享内存。即使用一个两个线程都能够共享的变量（如全局变量），这样两个线程都能够访问和修改该变量，从而达到共享数据的目的； 使用singal/slot机制，把数据从一个线程...
QT.rar_QT 多线程_QT 多线程_QT线程_qt多线程_多线程qt
07-14
8. **事件循环**：每个线程都有自己的事件循环，QThread通过exec()函数启动。在新线程中，如果没有启动事件循环，那么信号和槽机制将无法正常工作。 9. **线程与GUI**：主线程通常是GUI的事件循环所在的线程，而...
12 Qt4及Qt5的多线程编程
王木木
04-14 1826
一个可重入的类，指的是它的成员函数可以被多个线程安全地调用，只要每个线程使用这个类的不同的对象。而一个线程安全的类，指的是它的成员函数能够被多线程安全地调用，即使所有的线程都使用该类的同一个实例也没有关系。 QObject是可重入的。它的大多数非GUI子类，例如：QTimer、QTcpSocket、QUdpSocket和QProcess，也都是可重入的，这使得在多线程中同时使用这些类成为可能...
QT4用线程接受串口数据
12-16
QT4用线程接受串口数据
qt4 线程同步的小例子
08-24
一个QT下多线程编程的实例，很不错哦。对于初入线程编程的初学者是个不错的DEMO.
QT多线程和自定事件例子(有QT3和QT4二个版本)
10-19
QT多线程和自定事件例子(有QT3和QT4二个版本) 配合空间日记，方便大家下载！！ 有需要的请自行下载!!
QT4.8 创建线程及日志定期删除
12-13
简单的线程创建，可据此实现多线程任务，以及定期日志删除
QT基础4---线程
liyaoliy的博客
01-28 283
开一个线程：(QT4之前) 1)自定义一个类，继承于QThread class MyThread : public QThread { public: void run(); //才是线程处理函数（和主线程不在同一个线程） signal: void isDone(); //处理结束信号 } void run() { QThread::sleep(5); //睡眠5s 解决：放在线程里面处理 emit isDone(); } MyThread thread; timer.start(100); //启动线程
Qt4_创建线程
qq_36314864的博客
06-13 379
创建线程 在Qt应用程序中提供多钱程是非常简单的：只需要子类化QThread 并且重新实现它的 run()函数就可以了。为了显示这一过程是如何进行的，我们将从介绍一个非常简单的QThread子类的代码开始，它是一个可以在控制台上重复打印给定字符串的子类。应用程序的用户接口界面如： Thread.h #ifndef THREAD_H #define THREAD_H #include <QThread> class Thread : public QThread { Q_OBJECT
Qt4多线程编程示例
Lawrence的学习笔记
04-29 4052
本示例演示在窗口中启动一个线程，然后在线程中通过事件的方式与窗口进行通信，这是窗口与工作线程配合的普遍，而且比较安全的方法，推荐大家在窗口程序中使用多线程时使用这种方法，不要使用全局变量、文件等方式来处理窗口与线程间的通讯。 示例的头文件：class TMyThread; /* 窗口代码*/class TMyWidget : public QWidget
QT实战（18）：QT多线程1(QT4支持）
Bluenapa的博客
04-23 502
一 .线程启动方式一(QT4) 二 .线程启动方式二 （QT5）
Qt4_同步线程
qq_36314864的博客
06-13 233
同步线程 对于多线程应用程序，一个最基本要求就是能实现几个线程的同步执行。 Qt 提供了以下这几个用于同步的类：QMutex、QReadWriteLock、QSemaphore、QWaitCondition。 QMutex 类提供了一种保护一个变量或者一段代码的方法，这样就可以每次只让一个线程读取它。这个类提供了一个lock()函数来锁住互斥量 (mutex)。如果互斥量是解锁的 (unlock)，那么当前线程就立即占用并锁定(lock) 它；否则，当前线程就会被阻塞，直到掌握这个互斥量的线程对它解锁为止。
Qt线程任务队列demo实例解析
总结来说，该Qt线程任务队列demo项目应该是一个深入理解Qt多线程编程的优秀起点。开发者可以借助博客中的详细说明和源代码示例，学习如何在Qt环境下有效地使用线程，以及如何通过信号和槽机制进行线程间安全的通信。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值