12.2 多线程控制

最新推荐文章于 2024-06-18 17:10:01 发布

anhuizhj

最新推荐文章于 2024-06-18 17:10:01 发布

阅读量416

点赞数

分类专栏： Qt5开发及实例（第3版）文章标签： Qt5多线程互斥量信号量 QWaitCondition

本文链接：https://blog.csdn.net/anhuizhj/article/details/87352096

版权

Qt5开发及实例（第3版）专栏收录该内容

3 篇文章 1 订阅

订阅专栏

12.2 多线程控制

本节介绍Qt线程同步互斥控制的基本方法。线程之间存在着相互制约的关系，具体可分为互斥和同步这两种关系。

实现线程的互斥与同步常使用的类有QMutex、QMutexLocker、QReadWriteLocker、QReadLocker、QWriteLocker、QSemaphore和QWaitCondition。

下面举一个例子来说明问题：

class Key
{
public:
    Key() {key=0;}
    int createKey() {++key; return key;}
    int value() const {return key;}
private:
    int key;
};

这是实现生成从0开始递增并且不允许重复的值的Key类。

在多线程环境下，这个类是不安全的，因为存在多个线程同时修改私有成员key，其结果是不可预知的。

虽然类Key产生主键的函数createKey()只有一条语句执行修改成员变量key的值，但是C++的“++”操作符并不是原子操作，通常编译后，它将被展开成为以下三条机器命令：

● 将变量值载入寄存器。

● 将寄存器中的值加1。

● 将寄存器中的值写回主存。

假设当前的key值为0，如果线程1和线程2同时将0值载入寄存器，执行加1操作并将加1后的值写回主存，则结果是两个线程的执行结果将互相覆盖，实际上仅进行了一次加1操作，此时的key值为1。

为了保证类Key在多线程环境下正确执行，上面的三条机器指令必须串行执行且不允许中途被打断（原子操作），即线程1在线程2（或线程2在线程1）之前完整执行上述三条机器指令。

实际上，私有变量key是一个临界资源（Critical Resource，CR）。临界资源一次仅允许被一个线程使用，它可以是一块内存、一个数据结构、一个文件或者任何其他具有排他性使用的东西。在程序中，通常竞争使用临界资源。这些必须互斥执行的代码段称为“临界区（Critical Section，CS）”。临界区（代码段）实施对临界资源的操作，为了阻止问题的产生，一次只能有一个线程进入临界区。通常有相关的机制或方法在程序中加上“进入”或“离开”临界区等操作。如果一个线程已经进入某个临界区，则另一个线程就决不允许在此刻再进入同一个临界区。

12.2.1 互斥量

互斥量可通过QMutex或者QMutexLocker类实现。

1. QMutex类

QMutex类是对互斥量的处理。它被用来保护一段临界区代码，即每次只允许一个线程访问这段代码。

QMutex类的lock()函数用于锁住互斥量。如果互斥量处于解锁状态，则当前线程就会立即抓住并锁定它，否则当前线程就会被阻塞，直到持有这个互斥量的线程对它解锁。线程调用lock()函数后就会持有这个互斥量，直到调用unlock()操作为止。

QMutex类还提供了一个tryLock()函数。如果互斥量已被锁定，则理解返回。

例如：

class Key
{
public:
    Key() {key=0;}
    int createKey() {mutex.lock(); ++key; return key; mutex.unlock();}
    int value() const {mutex.lock(); return key; mutex.unlock();}
private:
    int key;
    QMutex mutex;
};

在上述的代码段中，虽然createKey()函数中使用mutex进行了互斥操作，但是unlock()操作却不得不在return之后，从而导致unlock()操作永远无法执行。同样，value()函数也存在这个问题。

2. QMutextLocker类

Qt提供的QMutexLocker类可以简化互斥量的处理，它在构造函数中接收一个QMutex对象作为参数并将其锁定，在析构函数中解除这个互斥量，这样就解决了以上问题。

例如：

class Key
{
public:
    Key() {key=0;}
    int createKey() {QMutexLocker locker(&mutex); ++key; return key;}
    int value() const {QMutexLocker locker(&mutex); return key;}
private:
    int key;
    QMutex mutex;
};

locker()函数作为局部变量会在函数退出时结束其作用域，从而自动对互斥量mutex解锁。

在实际应用中，一些互斥量锁定和解锁逻辑通常比较复杂，并且容易出错，而是用QMutexLocker类后，通常只需要这一条语句，从而大大简化了编程的复杂程度。

12.2.2 信号量

信号量可以理解为对互斥量的扩展，互斥量只能锁定一次而信号量可以获取多次，它可以用来保护一定数量的同种资源。信号量的典型用例是控制生产者/消费者之间共享的环形缓冲区。

生产者/消费者实例中对同步的需求有两处：

（1）如果生产者过快地生产数据，将会覆盖消费者还没有读取的数据。

（2）如果消费者过快地读取数据，将越过生产者并且读取一些过去数据。

针对以上问题，可以有两种解决方法：

（1）首先使生产者填满整个缓冲区，然后等待消费者读取整个缓冲区，这是一种比较笨拙的方法。

（2）使生产者和消费者线程同时分别操作缓冲区的不同部分，这是一种比较高效的方法。

【例】（难度一般）（CH1202）基于控制台程序实现。

（1）源文件“main.cpp”中添加的具体实现代码如下：

#include <QCoreApplication>
#include <QSemaphore>
#include <QThread>
#include <stdio.h>
const int DataSize = 1000;
const int BufferSize = 80;
int buffer[BufferSize];             //(a)
QSemaphore freeBytes(BufferSize);   //(b)
QSemaphore usedBytes(0);            //(c)

（2）Producer类继承自QThread类，作为生产者类，其声明如下：

class Producer : public QThread
{
public:
    Producer();
    void run();
};

其中，(a) int buffer[BufferSize]：首先生产者向buffer中写入数据，直到它到达终点，然后从起点重新开始覆盖已经存在的数据。消费者读取前者生产的数据，在此处每一个int字长都被看成一个资源，实际应用中常会在更大的单位上进行操作，从而减少使用信号量带来的开销。

(b) QSemaphore freeBytes(BufferSize)：freeBytes信号量控制可被生产者填充的缓冲区部分，被初始化为BufferSize(80)，表示程序一开始有BufferSize个缓冲区单元可被填充。

Producer构造函数中没有实现任何内容：

Producer::Producer()
{    
}

Producer::run()函数的具体实现代码如下：

void Producer::run()
{
    for (int i = 0; i < DataSize; i++)
    {
        freeBytes.acquire();                        //(a)
        buffer[i%BufferSize] = (i % BufferSize);    //(b)
        usedBytes.release();                        //(c)
    }
}

其中，(a) freeBytes.acquire()：生产者线程首先获取一个空闲单元，如果此时缓冲区被消费者尚未读取的数据填满，对此函数的调用就会阻塞，知道消费者读取了这些数据为止。

acquire(n)函数用于获取n个资源，当没有足够的资源时，调用者将被阻塞，直到有足够的可用资源为止。

除此之外，QSemaphore类还提供了一个tryAcquire(n)函数，在没有足够的资源时，该函数会理解返回。

(b) buffer[i%BufferSize] = (i%BufferSize)：一旦生产者获取了某个空闲单元，就使用当前的缓冲区单元序号填写这个缓冲区单元。

release(n)函数用于释放n个资源。

（3）Consumer类继承自QThread类，作为消费者类，其声明如下：

class Consumer : public QThread
{
public:
    Consumer();
    void run();
};

Consumer构造函数中没有实现任何内容：

Consumer::Consumer()
{
}

Consumer::run()函数的具体实现代码如下：

void Consumer::run()
{
    for (int i = 0; i < DataSize; i++)
    {
        usedBytes.acquire();                            //(a)
        fprintf(stderr, "%d", buffer[i%BufferSize]);    //(b)
        if (i % 16 == 0 && i != 0)
            fprintf(stderr, "\n");
        freeBytes.release();                            //(c)
    }
    fprintf(stderr, "\n");
}

其中，(a) usedBytes.acquire()：消费者线程首先获取一个可被读取的单元，如果缓冲区中没有包含任何可以读取的数据，对此函数的调用就会阻塞，直到生产者生产了一些数据位置。

(b) fprintf(stderr, "%d", buffer[i%BufferSize]：一旦消费者获取了这个单元，会将这个单元的内容打印出来。

（4）main()函数的具体代码如下：

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    Producer producer;
    Consumer consumer;
    /* 启动生产者和消费者线程 */
    producer.start();
    consumer.start();
    /* 等待生产者和消费者各自执行完毕后自动退出 */
    producer.wait();
    consumer.wait();
    return a.exec();
}

（5）最终运行结果如图12.3所示。

完整代码下载链接：https://download.csdn.net/download/anhuizhj/10959400

12.2.3 线程等待与唤醒

对生产者和消费者问题的另一个解决方法是使用QWaitCondition类，允许线程在一定条件下唤醒其他线程。

【例】（难度一般）（CH1203）使用QWaitCondition类解决生产者和消费者问题。

源文件“main.cpp”的具体内容如下：

#include <QCoreApplication>
#include <QWaitCondition>
#include <QMutex>
#include <QThread>
#include <stdio.h>
const int DataSize = 1000;
const int BufferSize = 80;
int buffer[BufferSize];
QWaitCondition bufferEmpty;
QWaitCondition bufferFull;
QMutex mutex;               //(a)
int numUsedBytes = 0;       //(b)
int rIndex = 0;             //(c)

其中，(a) QMutex mutex：使用互斥量保证对线程操作的原子性。

(b) int numUsedBytes = 0：变量numUsedBytes表示存在多少“可用字节”。

生产者线程Producer类继承自QThread类，其声明如下：

class Producer : public QThread
{
public:
    Producer();
    void run();
};

Producer构造函数无须实现：

Producer::Producer()
{
}

Producer::run()函数的具体内容如下：

void Producer::run()
{
    for (int i = 0; i < DataSize; i++)          //(a)
    {
        mutex.lock();
        if (numUsedBytes == BufferSize)         //(b)
            bufferEmpty.wait(&mutex);           //(c)
        buffer[i%BufferSize] = numUsedBytes;    //(d)
        ++numUsedBytes;                         //增加numUsedBytes变量
        bufferFull.wakeAll();                   //(e)
        mutex.unlock();
    }
}

其中，(a) for (int i = 0; i < DataSize; i++) { mutex.lock(); ... mutex.unlock(); }：for循环中的所有语句都需要使用互斥量加以保护，以保证其操作的原子性。

(b) if (numUsedBytes == BufferSize)：首先检查缓冲区是否已经填满。

bool QWaitCondition::wait
(
    QMutex *mutex;
    unsigned long time = ULONG_MAX
)

① 参数mutex为一个锁定的互斥量。如果此参数的互斥量在调用时不是锁定的或者出现递归锁定的情况，则wait()函数将立刻返回。

② 参数time为等待时间。

调用wait()操作的线程是的作为参数的互斥量在调用前首先变为解锁定状态，然后自身被阻塞变为等待状态知道满足以下条件之一：

● 其他线程调用了wakeOne()或者wakeAll()函数，这种情况下将返回“true”值。

● 第2个参数time超时（以毫秒为单位），该参数默认情况下为ULONG_MAX，表示永不超时，这种情况下将返回“false”值。

● wait()函数返回前会将互斥量参数重新设置为锁定状态，从而保证从锁定状态到等待状态的原子性转换。

(d) buffer[i%BufferSize] = numUsedBytes：如果缓冲区未被填满，则向缓冲区中写入一个整数值。

(e) bufferFull.wakeAll()：最后唤醒等待“缓冲区有可用数据”（bufferEmpty变量）条件为“真”的线程。

wakeOne()函数在条件满足时随机唤醒一个等待线程，而wakeAll()函数则在条件满足时唤醒所有等待线程。

消费者线程Consumer类继承自QThread类，其声明如下：

class Consumer : public QThread
{
public:
    Consumer();
    void run();
};

Consumer构造函数中无须实现内容：

Consumer::Consumer()
{
}

Consumer::run()函数的具体内容如下：

void Consumer::run()
{
    forever
    {
        mutex.lock();
        if (numUsedBytes == 0)
            bufferFull.wait(&mutex);        //(a)
        printf("%ul::[%d]=%d\n", currentThreadId(), rIndex, buffer[rIndex]);    //(b)
        rIndex = (++rIndex)%BufferSize;     //将rIndex变量循环加1
        --numUsedBytes;                     //(c)
        bufferEmpty.wakeAll();              //(d)
        mutex.unlock();
    }
    printf("\n");
}

其中，(a) bufferFull.wait(&mutex)：当缓冲区中无数据时，等待“缓冲区有可用数据”（bufferFull变量）条件成立。

(b) printf("%ul::[%d]=%d\n", currentThreadId(), rIndex, buffer[rIndex])：当缓冲区中有可用数据即条件成立时，打印当前线程号和rIndex变量，以及其指示的当前可读取数据。这里为了区分究竟是哪一个消费者线程消耗了缓冲区里的数据，使用了QThread类的currentThreadId()静态函数输出当前线程的ID。这个ID在X11环境下是一个unsigned long类型的值。

(d) bufferEmpty.wakeAll()：唤醒等待“缓冲区有空位”（bufferEmpty变量）条件的生产者线程。

main()函数的具体内容如下：

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    Producer producer;
    Consumer consumerA;
    Consumer consumerB;
    producer.start();
    consumerA.start();
    consumerB.start();
    producer.wait();
    consumerA.wait();
    consumerB.wait();
    return a.exec();
}

其中，consumerA.start()、ConsumerB.start()启动了两个消费者线程。

程序的最终的运行结果如图12.4所示。

完整代码下载地址：https://download.csdn.net/download/anhuizhj/10959566

anhuizhj

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
12.2 多线程控制

12.2 多线程控制本节介绍Qt线程同步互斥控制的基本方法。线程之间存在着相互制约的关系，具体可分为互斥和同步这两种关系。实现线程的互斥与同步常使用的类有QMutex、QMutexLocker、QReadWriteLocker、QReadLocker、QWriteLocker、QSemaphore和QWaitCondition。下面举一个例子来说明问题：class Key...
复制链接

扫一扫

专栏目录