Qt基础 | 多线程编程 | QThread | 线程同步 | QMutex | QMutexLocker | QReadWriteLock | QwaitCondition | QSemaphore

嵌入式_晚风

于 2024-07-27 21:53:19 发布

阅读量445

点赞数 13

分类专栏： # QT基础文章标签： qt QThread 线程同步 QMutex QReadWriteLock QwaitCondition QSemaphore

本文链接：https://blog.csdn.net/zwcslj/article/details/140741908

版权

QT基础专栏收录该内容

14 篇文章 6 订阅

订阅专栏

一、多线程介绍

一个应用程序一般只有一个线程，一个线程内的操作是顺序执行的，如果有某个比较消耗时间的计算或操作，如网络通信中的文件传输，在一个线程内操作时，用户界面就可能会冻结而不能及时响应。这种情况下，可以创建一个单独的线程来执行比较消耗时间的操作，并与主线程之间处理好同步与数据交互，这就是多线程应用程序。

Qt 为多线程操作提供了完整的支持。QThread 是线程类，是实现多线程操作的核心类，一般从 QThread 继承定义自己的线程类。线程之间的同步是其交互的主要问题，Qt 提供了 QMutex、QMutexLocker、QReadWriteLock、QwaitCondition、QSemaphore 等多种类用于实现线程之间的同步。Qt 还有 Qt Concurrent 模块，提供一些高级 API 实现多线程编程而无需使用 QMutex、QwaitCondition、QSemaphore 等基础操作。使用 Qt Concurrent 实现的多线程程序可以自动根据处理器内核个数调整线程个数。

二、QThread 创建多线程程序

1. QThread 类简介

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

QThread 类提供不依赖于平台的管理线程的方法。一个 QThread 类的对象管理一个线程，一般从 QThread 继承一个自定义类，并重定义虚函数 run()，在 run() 函数里实现线程需要完成的任务。

将应用程序的线程称为主线程，额外创建的线程称为工作线程。一般在主线程里创建工作线程，并调用 start() 开始执行工作线程的任务。start() 会在内部调用 run() 函数，进入工作线程的事件循环，在 run() 函数里调用 exit() 或 quit() 可以结束线程的事件循环，或在主线程里调用 terminate() 函数强制结束线程。

QThread 类的主要接口函数、信号、槽函数：

QThread 是 OObject 的子类，所以可以使用信号与槽机制。QThread 自身定义了 started() 和 finished() 两个信号，started() 信号在线程开始执行之前发射，也就是在 run() 函数被调用之前，finished() 信号在线程就要结束时发射。

2. 掷骰子的多线程应用程序

在子线程中完成多次掷骰子，并显示对应掷到骰子号码的图片。

2.1 掷骰子的线程 QDiceThread

从 QThread 继承一个线程类 QDiceThread，类的声明部分如下：

qdicethread.h：

#ifndef QDICETHREAD_H
#define QDICETHREAD_H

#include    <QThread>

class QDiceThread : public QThread
{
    Q_OBJECT
private:
    int     m_seq=0;//掷骰子次数序号
    int     m_diceValue;//骰子点数
    bool    m_Paused=true; //掷一次骰子
    bool    m_stop=false; //停止线程
protected:
    void    run() Q_DECL_OVERRIDE;  //线程任务
public:
    QDiceThread();

    void    diceBegin();//掷一次骰子
    void    dicePause();//暂停
    void    stopThread(); //结束线程
signals:
    void    newValue(int seq,int diceValue); //产生新点数的信号
};

#endif // QDICETHREAD_H

run() 函数：重载 run() 函数，在此函数中完成线程的主要任务。
m_Paused、m_stop成员变量用于控制线程的开启与结束、是否掷骰子
diceBegin()、dicePause()、stopThread() 函数用于线程控制，这 3 个函数由主线程调用
newValue() 信号，用于将掷骰子的次数与点数发送给主线程

qdicethread.cpp：

#include "qdicethread.h"
#include    <QTime>
#include <QDebug>

QDiceThread::QDiceThread()
{
    qDebug() << "QDiceThread constructor id =" << QThread::currentThreadId();
}

void QDiceThread::diceBegin()
{ //开始掷骰子
    qDebug() << "QDiceThread diceBegin id =" << QThread::currentThreadId();
    m_Paused=false;
}

void QDiceThread::dicePause()
{//暂停掷骰子
    m_Paused=true;
}

void QDiceThread::stopThread()
{//停止线程
    m_stop=true;
}

void QDiceThread::run()
{//线程任务
    m_stop=false;//启动线程时令m_stop=false
    m_seq=0; //掷骰子次数
    qsrand(QTime::currentTime().msec());//随机数初始化，qsrand是线程安全的
    qDebug() << "QDiceThread run id =" << QThread::currentThreadId();
    while(!m_stop)//循环主体
    {
        if (!m_Paused)
        {
            m_diceValue=qrand(); //获取随机数
            m_diceValue=(m_diceValue % 6)+1;
            m_seq++;
            emit newValue(m_seq,m_diceValue);  //发射信号
        }
        msleep(500); //线程休眠500ms
    }

//  在  m_stop==true时结束线程任务
    quit();//相当于  exit(0),退出线程的事件循环
}

run() 是线程任务的实现部分，线程开始就执行 run() 函数。 run() 函数一般是事件循环过程，根据各种条件或事件处理各种任务。当 run() 函数退出时，线程的事件循环就结束了。
run() 函数的主循环体是一个 while 循环，在主线程中调用 stopThread() 函数使 m_stop 为 true，才会退出 while 循环，调用 quit() 之后结束线程。
在 while 循环体内，又根据 m_Paused 判断当前是否需要掷骰子，如果需要掷骰子，则用随机函数生成一次骰子的点数m_diceValue，然后发出信号 newValue()，将m_seq 和 m_diceValue 作为信号参数传递出去。主线程可以设计槽函数与此信号关联，获取这两个值并进行显示。

2.2 主窗体

主窗体中的几个按钮用于控制线程的启动与停止，控制开始与暂停掷骰子。中间的文本框用于显示次数和点数，右边根据点数显示资源文件里面的图片。下方的标签用于显示线程的状态。

ui文件：

dialog.h：

#ifndef DIALOG_H
#define DIALOG_H

#include <QDialog>

#include    "qdicethread.h"

namespace Ui {
class Dialog;
}

class Dialog : public QDialog
{
    Q_OBJECT

private:
    QDiceThread   threadA;

protected:
    void    closeEvent(QCloseEvent *event);

public:
    explicit Dialog(QWidget *parent = 0);
    ~Dialog();

private slots:
    void    onthreadA_started();
    void    onthreadA_finished();
    void    onthreadA_newValue(int seq, int diceValue);

    void on_btnClear_clicked();
    void on_btnDiceEnd_clicked();
    void on_btnDiceBegin_clicked();
    void on_btnStopThread_clicked();
    void on_btnStartThread_clicked();

private:
    Ui::Dialog *ui;
};

#endif // DIALOG_H

定义了一个 QDiceThread 类型的变量 threadA，
重定义了 closeEvent() 事件，在窗口关闭时确保线程被停止

dialog.cpp：

#include "dialog.h"
#include "ui_dialog.h"
#include <QDebug>

void Dialog::closeEvent(QCloseEvent *event)
{ //窗口关闭事件，必须结束线程
    if (threadA.isRunning())
    {
        threadA.stopThread();
        threadA.wait();
    }
    event->accept();
}

Dialog::Dialog(QWidget *parent) : QDialog(parent),  ui(new Ui::Dialog)
{//构造函数
    ui->setupUi(this);
    qDebug() << "Dialog constructor id =" << QThread::currentThreadId();
    connect(&threadA,SIGNAL(started()),this,SLOT(onthreadA_started()));
    connect(&threadA,SIGNAL(finished()),this,SLOT(onthreadA_finished()));

    connect(&threadA,SIGNAL(newValue(int,int)),this,SLOT(onthreadA_newValue(int,int)));
}

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

void Dialog::onthreadA_started()
{//线程的started()信号的响应槽函数
    ui->LabA->setText("Thread状态：thread started");
}

void Dialog::onthreadA_finished()
{//线程的 finished()信号的响应槽函数
    ui->LabA->setText("Thread状态：thread finished");
}

void Dialog::onthreadA_newValue(int seq,int diceValue)
{//QDiceThread的newValue()信号的响应槽函数，显示骰子次数和点数
    QString  str=QString::asprintf("第 %d 次掷骰子，点数为：%d",seq,diceValue);
    ui->plainTextEdit->appendPlainText(str);

    QPixmap pic; //图片显示
    QString filename=QString::asprintf(":/dice/images/d%d.jpg",diceValue);
    pic.load(filename);
    ui->LabPic->setPixmap(pic);
}

void Dialog::on_btnClear_clicked()
{ //清空文本 按钮
    ui->plainTextEdit->clear();
}

void Dialog::on_btnDiceEnd_clicked()
{//暂停 掷骰子按钮
    threadA.dicePause();
    ui->btnDiceBegin->setEnabled(true);
    ui->btnDiceEnd->setEnabled(false);
}

void Dialog::on_btnDiceBegin_clicked()
{//开始 掷骰子按钮
    threadA.diceBegin();
    ui->btnDiceBegin->setEnabled(false);
    ui->btnDiceEnd->setEnabled(true);
}

void Dialog::on_btnStopThread_clicked()
{//结束线程 按钮
    threadA.stopThread();//结束线程的run()函数执行
    // threadA.wait();

    ui->btnStartThread->setEnabled(true);
    ui->btnStopThread->setEnabled(false);

    ui->btnDiceBegin->setEnabled(false);
    ui->btnDiceEnd->setEnabled(false);
}

void Dialog::on_btnStartThread_clicked()
{//启动线程 按钮
    threadA.start();

    ui->btnStartThread->setEnabled(false);
    ui->btnStopThread->setEnabled(true);

    ui->btnDiceBegin->setEnabled(true);
    ui->btnDiceEnd->setEnabled(false);
}

运行结果：

Dialog main id = 0x857c
QDiceThread constructor id = 0x857c
Dialog constructor id = 0x857c
QDiceThread run id = 0x8864
QDiceThread diceBegin id = 0x857c

分析上面的代码是如何处理线程同步的：

QT的信号槽机制是线程安全的，因此，可以避免主线程在读取m_seq与m_diceValue值时，子线程正在修改这两个值，相当于潜在的加了个锁，用信号槽机制确保了数据同步。
状态变量（如m_Paused和m_stop）的同步，diceBegin()、dicePause()、stopThread() 函数都只有一条赋值语句，可以认为是原子操作，所以不用锁定保护。执行过程不会被其他线程所干扰，只需要在子线程中加入检查点检查状态是否发生变化即可

三、线程同步

1.线程同步的概念

在多线程应用程序中，由于多个线程的存在，线程之间可能需要访问同一个变量，或一个线程需要等待另外一个线程完成某个操作后才产生相应的动作。在上一节的示例中，使用了信号槽机制（线程安全的），在产生新的骰子数之后通过信号通知主线程读取新的数据，由于信号槽机制是线程安全的，确保了在主线程读取新数据时，子线程不会修改数据产生新的值。

如果不使用信号与槽机制，QDiceThread 的 run() 函数变为如下代码：

void QDiceThread::run()
{//线程任务
    m_stop=false;//启动线程时令m_stop=false
    m_seq=0; //掷骰子次数
    qsrand(QTime::currentTime().msec());//随机数初始化，qsrand是线程安全的
    qDebug() << "QDiceThread run id =" << QThread::currentThreadId();
    while(!m_stop)//循环主体
    {
        if (!m_Paused)
        {
            m_diceValue=qrand(); //获取随机数
            m_diceValue=(m_diceValue % 6)+1;
            m_seq++;
        }
        msleep(500); //线程休眠500ms
    }

//  在  m_stop==true时结束线程任务
    quit();//相当于  exit(0),退出线程的事件循环
}

此时，QDiceThread 需要定义公共函数，用于访问 m_diceValue 的值，如：

int QDiceThread::diceValue() {	return m_diceValue;	}

diceValue() 函数用于在主线程中调用此函数读取骰子的点数。

由于没有信号与槽机制，主线程只能采用不断查询的方式主动查询是否有新数据，并读取它。但是在主线程调用 diceValue() 读取骰子点数时，工作线程可能正在执行 run() 函数来修改 m_diceValue 的值的语句，如：

m_diceValue=qrand(); //获取随机数
m_diceValue=(m_diceValue % 6)+1;
m_seq++;

这几条语句计算量较大，需要执行较长时间。执行这两条语句时不希望被主线程调用的 diceValue() 函数中断，如果中断，则主线程得到的可能是错误的值。

这种情况下，这段代码段是希望被保护起来的，在执行过程中不能被其他线程打断，以保证计算结果的完整性，这就是线程同步的概念。

在 Qt 中，有多个类可以实现线程同步的功能，包括 QMutex、QMutexLoker、QReadWriteLocker、QReadLocker、QWriteLocker、QWaitCondition 和 QSemapore。

2.基于互斥量的线程同步–QMutex 和 QMutexLoker

QMutex 和 QMutexLoker 是基于互斥量的线程同步类，QMutex 定义的实例是一个互斥量，

QMutex 主要有 3 个函数：

lock()：锁定互斥量，如果另外一个线程锁定了这个互斥量，它将阻塞执行直到其他线程解锁这个互斥量。
unlock()：解锁一个互斥量，需要与 lock() 配对使用。
tryLock()：试图锁定一个互斥量，如果成功锁定就返回 true；如果其他线程已经锁定了这个互斥量，就返回 false，但不阻塞程序执行。

使用互斥量，对 QDiceThread 类重新定义，提供一个函数用于主线程读取数据，保证线程同步。

qdicethread.h：

#ifndef QDICETHREAD_H
#define QDICETHREAD_H

//#include    <QObject>
#include    <QThread>
#include    <QMutex>

class QDiceThread : public QThread
{
    Q_OBJECT

private:
    QMutex  mutex; //互斥量

    int     m_seq=0;//序号
    int     m_diceValue;
    bool    m_paused=true;
    bool    m_stop=false; //停止线程
protected:
    void    run() Q_DECL_OVERRIDE;
public:
    QDiceThread();

    void    diceBegin();//掷一次骰子
    void    diceEnd();//
    void    stopThread();

    bool    readValue(int *seq, int *diceValue); //用于主线程读取数据的函数
};

#endif // QDICETHREAD_H

使用 QMutex 类定义一个互斥量变量 mutex
定义函数 readValue() ，用于外部线程读取掷骰子的次数和点数，传递参数采用指针变量，以便一次读取两个数据。

qdicethread.cpp：readValue() 和 run() 函数的实现代码

bool QDiceThread::readValue(int *seq, int *diceValue)
{
    if (mutex.tryLock())
    {
        *seq=m_seq;
        *diceValue=m_diceValue;
        mutex.unlock();
        return true;
    }
    else
        return false;
}

void QDiceThread::run()
{
    m_stop=false;//启动线程时令m_stop=false
    m_seq=0;
    qsrand(QTime::currentTime().msec());//随机数初始化，qsrand是线程安全的

    while(!m_stop)//循环主体
    {
        if (!m_paused)
        {
            mutex.lock();
            m_diceValue=qrand(); //获取随机数
            m_diceValue=(m_diceValue % 6)+1;
            m_seq++;
            mutex.unlock();
        }
        msleep(500); //线程休眠100ms
    }
}

在 run() 函数中，对重新计算骰子点数和掷骰子次数的 3 行代码用互斥量 mutex 的 lock() 和 unlock() 进行了保护，这部分代码的执行就不会被其他线程中断。

注意 lock() 与unlock() 必须配对使用。
在 readValue() 函数中，用互斥量 mutex 的 tryLock() 和 unlock() 进行了保护。如果 tryLock() 成功锁定互斥量，读取数值的两行代码执行时不会被中断，执行完后解锁；如果 tryLock() 锁定失败，函数立即返回，而不会等待。
原理上，对于两个或多个线程可能会同时读或写的变量都应该使用互斥量进行保护，例如：QDiceThread 中的变量 m_stop 与 m_paused，在子线程的 run() 函数中读取这两个变量，在主线程的 diceBegin()、dicePause()、stopThread() 函数里修改这两个变量。但是这 3 个函数都只有一条赋值语句，可以认为是原子操作，所以不用锁定保护。

在主窗口中，增加了一个定时器 mTimer 和时间溢出响应槽函数 onTimOut()，在 Dialog 的构造函数中将 mTimer 的 timeout 信号与此槽函数关联。在开启掷骰子时启动定时器，槽函数的主要功能是调用 threadA 的 readValue() 函数读取新数据。

void Dialog::onTimeOut()
{ //定时器到时处理槽函数
    int tmpSeq=0,tmpValue=0;
    bool  valid=threadA.readValue(&tmpSeq,&tmpValue); //读取数值
    if (valid && (tmpSeq!=mSeq)) //有效，并且是新数据
    {
        mSeq=tmpSeq;
        mDiceValue=tmpValue;
        QString  str=QString::asprintf("第 %d 次掷骰子，点数为：%d",mSeq,mDiceValue);
        ui->plainTextEdit->appendPlainText(str);
        QPixmap pic;
        QString filename=QString::asprintf(":/dice/images/d%d.jpg",mDiceValue);
        pic.load(filename);
        ui->LabPic->setPixmap(pic);
    }
}

QMutexLoker 是简化了互斥量处理的类。QMutexLoker 的构造函数接受一个互斥量作为参数并将其锁定，QMutexLoker 的析构函数则将此互斥量解锁，所以在 QMutexLoker 实例变量的生存周期内的代码段得到保护，自动进行互斥量的锁定和解锁。例如，QDiceThread 的 run() 函数代码可以改写为：

bool QDiceThread::readValue(int *seq, int *diceValue)
{
    if (mutex.tryLock())
    {
        *seq=m_seq;
        *diceValue=m_diceValue;
        mutex.unlock();
        return true;
    }
    else
        return false;
}

void QDiceThread::run()
{
    m_stop=false;//启动线程时令m_stop=false
    m_seq=0;
    qsrand(QTime::currentTime().msec());//随机数初始化，qsrand是线程安全的

    while(!m_stop)//循环主体
    {
        if (!m_paused)
        {
//            mutex.lock();
            QMutexLocker    Locker(&mutex);
            m_diceValue=qrand(); //获取随机数
            m_diceValue=(m_diceValue % 6)+1;
            m_seq++;
//            mutex.unlock();
        }
        msleep(500); //线程休眠100ms
    }
}

使用了 { } 来表示互斥锁保护的代码段，即 Locker 对象的作用域，一旦 Locker 超出其作用域，会自动解锁 mutex，run() 函数中不需要显式解锁。

3.基于 QReadWriteLock 的线程同步

使用互斥量时存在一个问题：每次只能有一个线程获得互斥量的权限。如果在一个程序中有多个线程读取某个变量，使用互斥量时就必须排队。而实际上若只是读取一个变量，是可以让多个线程同时访问的，这样互斥量就会降低程序的性能。

假设有一个数据采集程序，一个线程负责采集数据到缓冲区，一个线程负责读取缓冲区的数据并显示，另一个线程负责读取缓冲区的数据并保存到文件，示意代码如下：

int buffer[100];
QMutex  mutex;

void threadDAQ::run()
{
    mutex.lock();
    //数据写入到buffer
    mutex.unlock();
}

void threadShow::run()
{
    mutex.lock();
    //读取buffer里的数据并显示
    mutex.unlock();
}

void threadSaveFile::run()
{
    mutex.lock();
    //读取 buffer 里的数据并保存到文件
    mutex.unlock();
}

数据缓冲区 buffer 和互斥量 mutex 都是全局变量，线程 threadDAQ 将数据写到 buffer，线程 threadShow 和 threadSaveFile 只是读取 buffer，但是因为使用互斥量，这 3 个线程任何时候都只能有一个线程可以访问 buffer。实际上，threadShow 和 threadSaveFile 都只是读取 buffer 的数据，它们同时访问 buffer 是不会发生冲突的。

Qt 提供了 QReadWriteLock 类，它是基于读或写的模式进行代码段锁定的，在多个线程读写一个共享数据时，可以解决上面所说的互斥量存在的问题。

QReadWriteLock 以读或写锁定的同步方法允许以读或写的方式保护一段代码，它可以允许多个线程以只读方式同步访问资源，但是只要有一个线程在以写方式访问资源时，其他线程就必须等待直到写操作结束。

QReadWriteLock 提供的几个主要函数：

lockForRead()，以只读方式锁定资源，如果有其他线程以写入方式锁定，这个函数会阻塞；
lockForWrite()，以写入方式锁定资源，如果本线程或其他线程以读或写模式锁定资源，这个函数就阻塞
unlock()，解锁；
tryLockForRead()，lockForRead() 的非阻塞版本
tryLockForWrite()，lockForWrite() 的非阻塞版本。

使用 QReadWriteLock 改写上面的三线程代码，

int buffer[100];
QReadWriteLock  lock;

void threadDAQ::run()
{
    lock.lockForWrite();
    //数据写入到buffer
    lock.unlock();
}

void threadShow::run()
{
    lock.lockForRead();
    //读取buffer里的数据并显示
    lock.unlock();
}

void threadSaveFile::run()
{
    lock.lockForRead();
    //读取 buffer 里的数据并保存到文件
    lock.unlock();
}

这样，如果 threadDAQ 没有以 lockForWrite() 锁定 Lock，threadShow 和 threadSaveFile 可以同时访问 buffer，否则 threadShow 和 threadSaveFile 都被阻塞。如果 threadShow 和 threadSaveFile 没有锁定，那么 threadDAQ 能以写入方式锁定，否则 threadDAQ 就被阻塞。

QReadLocker 和 QWriteLocker 是 QReadWriteLock 的简便形式，如同 QMutexLocker 是 QMutex 的简便版本一样，无需与 unlock() 配对使用。使用 QReadLocker 和 QWriteLocker，则上面的代码改写为：

int buffer[100];
QReadWriteLock  lock;

void threadDAQ::run()
{
    QWriteLocker Locker(&lock);
    //数据写入到buffer
    //...
}

void threadShow::run()
{
    QReadLocker  Locker(&lock);
    //读取buffer里的数据并显示
    //...
}

void threadSaveFile::run()
{
    QReadLocker  Locker(&lock);
    //读取 buffer 里的数据并保存到文件
    //...
}

4.基于 QWaitCondition 的线程同步

5.基于信号量的线程同步

嵌入式_晚风

关注

13
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Qt基础 | 多线程编程 | QThread | 线程同步 | QMutex | QMutexLocker | QReadWriteLock | QwaitCondition | QSemaphore

一个应用程序一般只有一个线程，一个线程内的操作是顺序执行的，如果有某个比较消耗时间的计算或操作，如网络通信中的文件传输，在一个线程内操作时，用户界面就可能会冻结而不能及时响应。这种情况下，可以创建一个单独的线程来执行比较消耗时间的操作，并与主线程之间处理好同步与数据交互，这就是多线程应用程序。Qt 为多线程操作提供了完整的支持。QThread 是线程类，是实现多线程操作的核心类，一般从 QThread 继承定义自己的线程类。
复制链接

扫一扫

专栏目录