专栏首页编程学习基地Qt多线程编程之线程的同步和互斥

Qt多线程编程之线程的同步和互斥

线程同步基础

临界资源每次只允许一个线程进行访问的资源

线程间互斥多个线程在同一时刻都需要访问临界资源

线程锁能够保证临界资源的安全性,通常,每个临界资源需要一个线程锁进行保护

线程死锁线程间相互等待临界资源而造成彼此无法继续执行。

产生死锁的条件

A、系统中存在多个临界资源且临界资源不可抢占

B、线程需要多个临界资源才能继续执行

死锁的避免

A、对使用的每个临界资源都分配一个唯一的序号

B、对每个临界资源对应的线程锁分配相应的序号

C、系统中的每个线程按照严格递增的次序请求临界资源

QMutex, QReadWriteLock, QSemaphore, QWaitCondition 提供了线程同步的手段。使用线程的主要想法是希望它们可以尽可能并发执行,而一些关键点上线程之间需要停止或等待。例如,假如两个线程试图同时访问同一个全局变量,结果可能不如所愿。

互斥量QMutex

QMutex 提供相互排斥的锁,或互斥量。在一个时刻至多一个线程拥有mutex,假如一个线程试图访问已经被锁定的mutex,那么线程将休眠,直到拥有mutex的线程对此mutex解锁。QMutex常用来保护共享数据访问。QMutex类所以成员函数是线程安全的。

头文件声明:#include <QMutex>

互斥量声明:QMutex m_Mutex;

互斥量加锁:m_Mutex.lock();

互斥量解锁:m_Mutex.unlock();

如果对没有加锁的互斥量进行解锁,结果是未知的。

示例场景:

继承QThread类实现多线程

#ifndef MYTHREAD_H
#define MYTHREAD_H
#include <QObject>
#include <QThread>

class MyThread : public QThread
{
    Q_OBJECT
public:
    MyThread();
protected:
    virtual void run();
private:
};
#endif // MYTHREAD_H

#include "mythread.h"
#include <QDebug>
extern int global_Val;
MyThread::MyThread()
{
    qDebug()<<"mainThread::currentId:"<<QThread::currentThreadId();
}

void MyThread::run()
{
    while (global_Val>0) {
        qDebug()<<"threadId:"<< QThread::currentThreadId()<<"  global_val:"<<global_Val--;
//        QThread::msleep(200);
    }
    qDebug()<<"Task finish";
}

#include <QCoreApplication>
#include "mythread.h"
int global_Val = 10;
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    MyThread thread1,thread2;
    thread1.start();
    thread2.start();
    return a.exec();
}

定义全局变量,两个线程都可以访问,当两个线程同时访问时,会发生资源的争夺,造成不可预知的

程序运行结果如下

mainThread::currentId: 0x222c
mainThread::currentId: 0x222c
threadId: 0x3df4   global_val: 10
threadId: 0x3df4   global_val: 8
threadId: 0x3df4   global_val: 7
threadId: 0x10b8   global_val: 9
threadId: 0x3df4   global_val: 6
threadId: 0x10b8   global_val: 5
threadId: 0x3df4   global_val: 4
threadId: 0x3df4   global_val: 2
threadId: 0x3df4   global_val: 1
threadId: 0x10b8   global_val: 3
Task finish
Task finish

可以看到数据是乱的,这是没加锁的情况,接下来加上锁

#include "mythread.h"
#include <QDebug>
extern int global_Val;
extern QMutex globlMutex;   //锁一定是全局的
MyThread::MyThread()
{
    qDebug()<<"mainThread::currentId:"<<QThread::currentThreadId();
}

void MyThread::run()
{
    while (global_Val>0) {
        globlMutex.lock();
        qDebug()<<"threadId:"<< QThread::currentThreadId()<<"  global_val:"<<global_Val--;
//        QThread::msleep(200);
        globlMutex.unlock();
    }
    qDebug()<<"Task finish";
}

互斥量的加锁和解锁必须在同一线程中成对出现。

运行之后就不会出现资源抢夺造成数据丢失等等问题了

mainThread::currentId: 0x3b28
mainThread::currentId: 0x3b28
threadId: 0x1ae8   global_val: 10
threadId: 0x1024   global_val: 9
threadId: 0x1ae8   global_val: 8
threadId: 0x1024   global_val: 7
threadId: 0x1ae8   global_val: 6
threadId: 0x1024   global_val: 5
threadId: 0x1ae8   global_val: 4
threadId: 0x1024   global_val: 3
threadId: 0x1ae8   global_val: 2
threadId: 0x1024   global_val: 1
Task finish
threadId: 0x1ae8   global_val: 0
Task finish

如果觉得10太小了可以换成100,在未加锁的情况下数据的丢失更为严重

互斥锁QMutexLocker

在较复杂的函数和异常处理中对QMutexmutex对象进行lock()和unlock()操作将会很复杂,进入点要lock(),在所有跳出点都要unlock(),很容易出现在某些跳出点未调用unlock(),所以Qt引进了QMutex的辅助类QMutexLocker来避免lock()unlock()操作。在函数需要的地方建立QMutexLocker对象,并把mutex指针传给QMutexLocker对象,此时mutex已经加锁,等到退出函数后,QMutexLocker对象局部变量会自己销毁,此时mutex解锁。

头文件声明:    #include<QMutexLocker>

互斥锁声明:    QMutexLocker mutexLocker(&m_Mutex);

互斥锁加锁:    从声明处开始(在构造函数中加锁)

互斥锁解锁:    出了作用域自动解锁(在析构函数中解锁)

使用互斥锁进行线程的同步

#include "mythread.h"
#include <QDebug>
extern int global_Val;
extern QMutex globlMutex;   //锁一定是全局的
MyThread::MyThread()
{
    qDebug()<<"mainThread::currentId:"<<QThread::currentThreadId();
}

void MyThread::run()
{
    while (global_Val>0) {
        QMutexLocker locker(&globlMutex);
        qDebug()<<"threadId:"<< QThread::currentThreadId()<<"  global_val:"<<global_Val--;
//        QThread::msleep(200);
    }
    qDebug()<<"Task finish";
}

条件变量QWaitCondition

Qt里面叫等待条件,Linux下叫条件变量,我统一都称呼为条件变量

QWaitCondition 允许线程在某些情况发生时唤醒另外的线程。一个或多个线程可以阻塞等待QWaitCondition ,用wakeOne()或wakeAll()设置一个条件。wakeOne()随机唤醒一个,wakeAll()唤醒所有

QWaitCondition ()

bool wait ( QMutex * mutex, unsigned long time = ULONG_MAX )

bool wait ( QReadWriteLock * readWriteLock, unsigned long time = ULONG_MAX )

void wakeOne ()

void wakeAll ()

头文件声明:    #include <QWaitCondition>

等待条件声明:    QWaitCondtion m_WaitCondition;

等待条件等待:    m_WaitConditon.wait(&m_muxtex, time);

等待条件唤醒:    m_WaitCondition.wakeAll();

在经典的生产者-消费者场合中,生产者首先必须检查缓冲是否已满,如果缓冲区已满,线程停下来等待 notfull条件。如果没有满,在缓冲中生产数据,激活条件 nottempty。使用mutex来保护对buffer的访问。QWaitCondition::wait() 接收一个mutex作为参数,mutex被调用线程初始化为锁定状态。在线程进入休眠状态之前,mutex会被解锁。而当线程被唤醒时,mutex会处于锁定状态,从锁定状态到等待状态的转换是原子操作。当程序开始运行时,只有生产者可以工作,消费者被阻塞等待nottempty条件,一旦生产者在缓冲中放入一个字节,nottempty条件被激发,消费者线程于是被唤醒。

生产者和消费者示例:

#include <QtCore/QCoreApplication>
#include <QThread>
#include <QWaitCondition>
#include <QMutex>
#include <QDebug>
#define BUFFER_SIZE 2

/*生产者*/
class producons
{
public:
    int buffer[BUFFER_SIZE];    /*数据*/
    QMutex lock;                //互斥锁
    int readpos,writepos;       //读写位置
    QWaitCondition nottempty;   //条件变量  没有空间
    QWaitCondition notfull;     //条件变量  没有货物

    producons()
    {
        readpos = writepos = 0;
    }
};
producons buffer;    //生产者对象

class Producor:public QThread
{
public:
    void run();
    void put(producons * prod,int data);
};

void Producor::run()
{
    int n;
    for(n = 0;n<5;n++)
    {
        qDebug()<<"生产者睡眠 1s...";
        sleep(1);
        qDebug()<<"生产信息:" << n;
        put(&buffer, n);
    }
    for(n=5; n<10; n++)
    {
        qDebug()<<"生产者睡眠 3s...";
        sleep(3);
        qDebug()<<"生产信息:"<< n;
        put(&buffer,n);
    }
    put(&buffer, -1);
    qDebug()<<"结束生产者!\n";
    return;
}
void Producor::put(producons *prod, int data)
{
    prod->lock.lock();

    //write until buffer not full
    while((prod->writepos + 1)%BUFFER_SIZE == prod->readpos)
    {
        qDebug()<<"生产者等待生产,直到buffer有空位置";
        prod->notfull.wait(&prod->lock);
    }
    //将数据写入到buffer里面去
    prod->buffer[prod->writepos] = data;
    prod->writepos++;
    if(prod->writepos >= BUFFER_SIZE)
        prod->writepos = 0;
    //仓库已满,等待消费者消费
    prod->nottempty.wakeAll();
    prod->lock.unlock();
}

class Consumer:public QThread
{
public:
    void run();
    int get(producons *prod);
};

void Consumer::run()
{
    int d = 0;
    while(1)
    {
        qDebug()<<"消费者睡眠 2s...";
        sleep(2);
        d = get(&buffer);
        qDebug()<<"读取信息:"<< d;
        if(d == -1) break;
    }
    qDebug()<<"结束消费者!";
    return;
}

int Consumer::get(producons *prod)
{
    int data;
    prod->lock.lock();      //加锁

    while(prod->writepos == prod->readpos)
    {
        qDebug()<<"消费者等待,直到buffer有消息\n";
        prod->nottempty.wait(&prod->lock);
    }
    //读取buffer里面的消息
    data = prod->buffer[prod->readpos];
    prod->readpos++;

    if(prod->readpos >=BUFFER_SIZE)
        prod->readpos = 0;
    //触发非满条件变量 告诉生产者可以生产
    prod->notfull.wakeAll();
    prod->lock.unlock();

    return data;
}
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    Producor productor;
    Consumer consumer;
    productor.start();
    consumer.start();
    productor.wait();
    consumer.wait();
    return a.exec();
}
生产者睡眠 1s...
消费者睡眠 2s...
生产信息: 0
生产者睡眠 1s...
读取信息: 0
生产信息: 1
消费者睡眠 2s...
生产者睡眠 1s...
生产信息: 2
生产者等待生产,直到buffer有空位置
读取信息: 1
生产者睡眠 1s...
消费者睡眠 2s...
生产信息: 3
生产者等待生产,直到buffer有空位置
读取信息: 2
生产者睡眠 1s...
消费者睡眠 2s...
生产信息: 4
生产者等待生产,直到buffer有空位置
读取信息: 3
生产者睡眠 3s...
消费者睡眠 2s...
读取信息: 4
消费者睡眠 2s...
生产信息: 5
生产者睡眠 3s...
读取信息: 5
消费者睡眠 2s...
生产信息: 6
消费者等待,直到buffer有消息

生产者睡眠 3s...
读取信息: 6
消费者睡眠 2s...
消费者等待,直到buffer有消息

生产信息: 7
生产者睡眠 3s...
读取信息: 7
消费者睡眠 2s...
消费者等待,直到buffer有消息

生产信息: 8
生产者睡眠 3s...
读取信息: 8
消费者睡眠 2s...
消费者等待,直到buffer有消息

生产信息: 9
生产者等待生产,直到buffer有空位置
读取信息: 9
消费者睡眠 2s...
结束生产者!

读写锁QReadWriteLock

QReadWriterLockQMutex相似,但对读写操作访问进行区别对待,可以允许多个读者同时读数据,但只能有一个写,并且写读操作不同同时进行。使用QReadWriteLock而不是QMutex,可以使得多线程程序更具有并发性。 QReadWriterLock默认模式是NonRecursive

QReadWriterLock类成员函数如下:

QReadWriteLock ( )
QReadWriteLock ( RecursionMode recursionMode )
void lockForRead ()
void lockForWrite ()
bool tryLockForRead ()
bool tryLockForRead ( int timeout )
bool tryLockForWrite ()
bool tryLockForWrite ( int timeout )
boid unlock ()

使用示例:

QReadWriteLock lock;
void ReaderThread::run()
{
    lock.lockForRead();
    read_file();
    lock.unlock();
}
void WriterThread::run()
{
    lock.lockForWrite();
    write_file();
    lock.unlock();
}

QReadLocker和QWriteLocker

在较复杂的函数和异常处理中对QReadWriterLocklock对象进行lockForRead()/lockForWrite()unlock()操作将会很复杂,进入点要lockForRead()/lockForWrite(),在所有跳出点都要unlock(),很容易出现在某些跳出点未调用unlock(),所以Qt引进了QReadLockerQWriteLocker类来简化解锁操作。在函数需要的地方建立QReadLockerQWriteLocker对象,并把lock指针传给QReadLockerQWriteLocker对象,此时lock已经加锁,等到退出函数后,QReadLockerQWriteLocker对象局部变量会自己销毁,此时lock解锁

QReadWriteLock lock;
QByteArray readData()
{
    QReadLocker locker(&lock);
    ...
    return data;
}

信号量QSemaphore

QSemaphoreQMutex一般化,是特殊的线程锁,允许多个线程同时访问临界资源,而一个QMutex只保护一个临界资源。QSemaphore 类的所有成员函数是线程安全的。

QSemaphore 类成员函数:

QSemaphore ( int n = 0 )
void acquire ( int n = 1 )
int available () const
void release ( int n = 1 )
bool tryAcquire ( int n = 1 )
bool tryAcquire ( int n, int timeout )

伪代码:

const int BufferSize = 8192;
QSemaphore  production(BufferSize);
QSemaphore  consumption;

production.acquire();
//对BufferSize锁着后操作
consumption.release();

End

本文分享自微信公众号 - 编程学习基地(LearnBase),作者:DeRoy

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2020-09-06

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Qt多线程编程之线程池

    线程的创建及销毁需要与系统交互,会产生很大的开销。若需要频繁的创建线程建议使用线程池,有线程池维护一定数量的线程,当需要进行多线程运算时将运算函数传递给线程池即...

    DeROy
  • qt国际化

    Translate_CN.ts 汉语­>汉语(一般不用改,我们使用的是汉语,只需要改汉译英的)

    DeROy
  • 十大经典排序算法(代码实现),建议收藏

    兜兜转转,一晃年关将至。时间证明了一个道理,学啥忘啥,学的越快忘得越快,还不如踏踏实实写点笔记心得来的实在。

    DeROy
  • 我在Python的艳阳里,大雪纷飞

    你在南方的艳阳里大雪纷飞;我在北方的寒夜里四季如春。 昨天,南方不少地区,尤其是长江中下游一带迎来了一场难得的大雪。虽说给出行带来极大的不便,但也让我们这些没怎...

    Crossin先生
  • JQuery JCshare 0.1 分享插件

    一、介绍:     现在各类SNS网站、微博等都开设了分享接口,可以让你的咨询更快、更有效的通过用户分享给其好友,外面也有很多一键式的分享控件。我们公司...

    脑洞的蜂蜜
  • 11个技巧让你编写出更好的Python代码

    在本教程中,我们将展示11个技巧来编写更好的Python代码!我们展示了许多最佳实践,它们通过使代码更加简洁和更具python风格来改进代码。以下是所有技巧的概...

    HuangWeiAI
  • 使用Yolov5进行端到端目标检测

    最近,Ultralytics推出了YOLOv5,但它的名字却引发了争议。为了了解背景,《YOLO》(你只能看一次)的前三个版本是由约瑟夫·雷蒙(Joseph R...

    deephub
  • 如何使用Yolov5创建端到端对象检测器?

    Ultralytics最近在围绕其名称的争议中推出了YOLOv5。就上下文而言,约瑟夫·雷德蒙(Joseph Redmon)创建了YOLO(您只看一次)的前三个...

    代码医生工作室
  • 搭建家校共育新渠道 江浙沪百余校长共话未来教育新模式

    2020年上半年,新冠肺炎疫情的爆发,给整个教育行业带来了巨大的影响:课堂从线下搬到了线上,在线教育成为保障学校教育教学正常开展的主要手段;与此同时,假期的延...

    鹅老师
  • 剑指Offer的学习笔记(C#篇)-- 二进制中1的个数

    新颖的解法,使得该题目运用到了二进制的位运算符。先了解一下位运算符!

    WeiMLing

扫码关注云+社区

领取腾讯云代金券