Qt线程同步的几种方法

最新推荐文章于 2024-08-14 00:41:19 发布

e5Max

最新推荐文章于 2024-08-14 00:41:19 发布

阅读量1w

点赞数 9

分类专栏： Qt 文章标签： Qt 多线程线程同步

Qt 专栏收录该内容

39 篇文章 1 订阅

订阅专栏

本文详细介绍了Qt中的多种并发编程机制，包括QMutex、QMutexLocker、QReadWriteLock、QReadLocker/QWriteLocker、QSemaphore及QWaitCondition等，并探讨了它们在实际场景中的应用。

摘要由CSDN通过智能技术生成

一、QMutex类

QMutex类就像一把锁，在互斥量之前上锁（QMutex::lock()），然后在使用完互斥量之后解锁（QMutex::unlock()）。比如下面的代码：

void someMethod()
{
    mutex.lock();
    qDebug()<<"Hello";
    qDebug()<<"World";
    mutex.unlock();
}
 
class Thread1 : public QThread  
{
protected:
    virtual void run()
    {
        someMethod();
    }
};
 
class Thread2 : public QThread  
{
protected:
    virtual void run()
    {
        someMethod();
    }
};

如上面的代码，在函数someMethod里面有两条语句，如果有两个线程启动之后，这两个线程都将调用这个函数（run函数即为线程启动后自动执行的函数），则可能会出现的结果是Hello Hello World World。但显然，这并不是我们想要的，我们希望的是每个线程可以一次性执行完someMethod函数里面的代码。这个时候我们便可以在函数里面给函数体加上锁，然后在结束的时候解锁。

这里需要注意的是，如果一个线程试图向一个已经被其它线程上锁了互斥量上锁的话，这个线程将被阻塞（挂起），直到这个互斥量被解锁。如果一个线程希望自己在试图对一个上锁了的互斥量进行访问的时候能够不被阻塞（而是立即返回），可以将lock()函数替换为tryLock()函数，这个函数的效果是：如果线程正在试图访问的互斥量已经被上锁了，那么可以立即返回而不被阻塞。

二、QMutexLocker便利类

使用 QMutex 对互斥量进行加锁解锁比较繁琐，在一些复杂的函数或者抛出C++异常的函数中都非常容易发生错误。可以使用一个方便的 QMutexLocker 类来简化对互斥量的处理。首先，QMutexLocker类的构造函数接收一个QMutex对象作为参数并且上锁，然后在析构函数中自动对其进行解锁。如下代码：


QMutex mutex;
 
void someMethod()
{
    QMutexLocker locker(&mutex);
    qDebug()<<"Hello";
    qDebug()<<"World";
}

这里创建一个QMutexLocker类实例，在这个实例的构造函数中将对mutex对象进行加锁。然后在析构函数中自动对mutex进行解锁。解锁的工作不需要显示地调用unlock函数，而是根据QMutexLocker对象的作用域绑定在一起了。

三、QReadWriteLock类

前两种保护互斥量的方法比较绝对，其达到的效果是：不管我要对互斥量做些是什么，我都要一个人霸占着，即使我只是看看它，也不能让别人看。这会使得这个互斥量资源的使用率大大下降，造成资源等待等问题。

于是，我们可以对线程对互斥量的操作进行分类：读和写。有几种情况：

1、如果我只是看看的话，你也可以看，大家看到的都是正确的结果；

2、如果我要看这个数据，你是不能改的，不然我看到的结果就不知道是什么了；

3、我在改的时候，你不能看，否则我可能会让你看到不正确的结果；

4、我在改的时候，你当然不能改了。

因此，我们可以对QMutex锁进行升级，将其升级为QReadWriteLock，QMutex加锁的方法是lock()，而QReadWriteLock锁有两种锁法：设置为读锁（lockForRead()）和写锁（lockForWrite()）。代码如下：

QReadWriteLock lock;
void someMethod()
{
lock.lockForRead(); //为读而锁
//lock.lockForWrite(); //为写而锁
qDebug()<<"Hello";
qDebug()<<"World";

lock.unlock();  //解锁
}

于是可能有以下四种情况：

1、一个线程试图对一个加了读锁的互斥量进行上读锁，允许；

2、一个线程试图对一个加了读锁的互斥量进行上写锁，阻塞；

3、一个线程试图对一个加了写锁的互斥量进行上读锁，阻塞；

4、一个线程试图对一个加了写锁的互斥量进行上写锁，阻塞。

所以可以看出，读写锁比较适用的情况是：需要多次对共享的数据进行读操作的阅读线程。

四、QReadLocker便利类和QWriteLocker便利类对QReadWriteLock进行加解锁

和QMutex与QMutexLocker类的关系类似，关于读写锁也有两个便利类，读锁和写锁，QReadLocker和QWriteLocker。它们的构造函数都是一个QReadWriteLock对象，不同的是，在QReadLocker的构造函数里面是对读写锁进行lockForRead()加锁操作，而在QWriteLocker的构造函数里面是对读写锁进行lockForWrite()加锁操作。然后解锁操作unlock()都是在析构函数中完成的。

void write()
{
QReadLocker locker(&lock);
..........
}

void read()
{
QWriteLocker locker(&lock);
..............
}

QReadLocker和QWriteLocker的成员函数都一模一样，退出函数的时局部变量locker会自动销毁，讲lock自动解锁。也可以调用locker.unlock()给lock解锁，然后再调用locker.relock()再锁住lock。也可以调用locker.readWriteLock(）获取建立locker时引入的那个lock的指针。

五、信号量QSemaphore

前面的几种锁都是用来保护只有一个变量的互斥量的。但是还有些互斥量（资源）的数量并不止一个，比如一个电脑安装了2个打印机，我已经申请了一个，但是我不能霸占这两个，你来访问的时候如果发现还有空闲的仍然可以申请到的。于是这个互斥量可以分为两部分，已使用和未使用。一个线程在申请的时候，会对未使用到的部分进行加锁操作，如果加锁失败则阻塞，如果加锁成功，即又有一个资源被使用了，于是则将已使用到的部分解锁一个。

以著名的生产者消费者问题为例，分析问题：生产者需要的是空闲位置存放产品，结果是可取的产品多了一个。于是，我们可以定义两个信号量：QSemaphore freeSpace和QSemaphore usedSpace，前者是给生产者使用的，后者是给消费者使用的。