【QT之 QWaitCondition】

最新推荐文章于 2024-02-14 17:13:28 发布

PinoLio

最新推荐文章于 2024-02-14 17:13:28 发布

阅读量891

点赞数 22

分类专栏： QT 文章标签： qt 开发语言

本文链接：https://blog.csdn.net/m0_56066265/article/details/134729820

版权

QT 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

QWaitCondition Class

QWaitCondition类提供了一个用于同步线程的条件变量.

描述

QWaitCondition允许线程告诉其他线程某种条件已经满足。一个或多个线程可以阻止等待QWaitCondition使用wakeOne()或wakeAll()设置条件。使用wakeOne()唤醒一个随机选择的线程，或使用wakeAll()唤醒所有线程。
例如，假设我们有三个任务，每当用户按下某个键时都应该执行。每个任务都可以拆分成一个线程，每个线程都有一个run（）主体，如下所示：

forever {
    mutex.lock();
    keyPressed.wait(&mutex);//这里，keyPressed变量是QWaitCondition类型的全局变量。
    do_something();
    mutex.unlock();
}

第四个线程将读取按键，并在每次收到按键时唤醒其他三个线程，如下所示：第四个线程将读取按键，并在每次收到按键时唤醒其他三个线程，如下所示：

forever {
    getchar();
    keyPressed.wakeAll();
}

三个线程被唤醒的顺序是未定义的。此外，如果按键时某些线程仍在do_something（）中，则它们不会被唤醒（因为它们没有等待条件变量），因此不会为该按键执行任务。这个问题可以使用计数器和QMutex来保护它。例如，下面是工作线程的新代码：

forever {
    mutex.lock();
    keyPressed.wait(&mutex);
    ++count;
    mutex.unlock();

    do_something();

    mutex.lock();
    --count;
    mutex.unlock();
}

以下是第四个线程的代码：

forever {
    getchar();

    mutex.lock();
    // Sleep until there are no busy worker threads
    while (count > 0) {
        mutex.unlock();
        sleep(1);
        mutex.lock();
    }
    keyPressed.wakeAll();
    mutex.unlock();
}

互斥是必要的，因为两个线程试图同时更改同一变量的值的结果是不可预测的。
等待条件是一个强大的线程同步原语。等待条件示例展示了如何使用QWaitCondition作为QSemaphore的替代方案，以控制对生产者线程和消费者线程共享的循环缓冲区的访问。

成员函数

QWaitCondition::QWaitCondition()
//构造一个新的等待条件的对象
QWaitCondition::~QWaitCondition()

void QWaitCondition::notify_all()
//提供此功能是为了与STL兼容。它相当于wakeAll（）。
void QWaitCondition::notify_one()
//提供此功能是为了与STL兼容。它相当于wakeOne（）。
bool QWaitCondition::wait(QMutex *lockedMutex, unsigned long time)
//重载函数
bool QWaitCondition::wait(QReadWriteLock *lockedReadWriteLock, unsigned long time)

void QWaitCondition::wakeAll()
//唤醒所有在等待条件下等待的线程。线程的唤醒顺序取决于操作系统的调度策略，无法控制或预测。

void QWaitCondition::wakeOne()
//唤醒一个在等待条件下等待的线程。被唤醒的线程取决于操作系统的调度策略，并且无法控制或预测。
//如果你想唤醒一个特定的线程，解决方案通常是使用不同的等待条件，让不同的线程在不同的条件下等待。

bool QWaitCondition::wait(QMutex *lockedMutex, QDeadlineTimer deadline = QDeadlineTimer(QDeadlineTimer::Forever))

释放lockedMutex，并在等待条件下等待。lockedMutex必须首先由调用线程锁定。如果lockedMutex未处于锁定状态，则行为未定义。如果lockedMutex是递归互斥，则此函数会立即返回。lockedMutex将被解锁，调用线程将阻塞，直到满足以下任一条件：
1、另一个线程使用wakeOne()或wakeAll()发出信号。在这种情况下，此函数将返回true。
2、deadline 时间已到。如果最后期限是QDeadlineTimer::Forever（默认值），则等待永远不会超时（必须向事件发出信号）。如果等待超时，此函数将返回false。
lockedMutex将返回到相同的锁定状态。提供此功能是为了允许原子从锁定状态转换到等待状态。

bool QWaitCondition::wait(QReadWriteLock *lockedReadWriteLock, QDeadlineTimer deadline = QDeadlineTimer(QDeadlineTimer::Forever))

释放锁定的ReadWriteLock并等待等待条件。lockedReadWriteLock最初必须由调用线程锁定。如果lockedReadWriteLock未处于锁定状态，则此函数会立即返回。lockedReadWriteLock不能递归锁定，否则此函数将无法正确释放锁。lockedReadWriteLock将被解锁，调用线程将阻塞，直到满足以下任一条件：
1、另一个线程使用wakeOne()或wakeAll()发出信号。在这种情况下，此函数将返回true。
2、deadline 时间已到。如果最后期限是QDeadlineTimer::Forever（默认值），则等待永远不会超时（必须向事件发出信号）。如果等待超时，此函数将返回false。
lockedReadWriteLock将返回到相同的锁定状态。提供此功能是为了允许原子从锁定状态转换到等待状态。

Wait Conditions Example(案例)

生产者将数据写入缓冲区，直到数据到达缓冲区的末尾，然后从头开始重新启动，覆盖现有数据。使用者线程在生成数据时读取数据，并将其写入标准错误。
Wait Conditions可以使并发级别高于单独使用互斥对象时的并发级别。如果对缓冲区的访问只是由QMutex保护，那么使用者线程就不能与生产者线程同时访问缓冲区。然而，让两个线程同时在缓冲区的不同部分工作并没有坏处。
该示例包括两个类：生产者和消费者。两者都继承自QThread。用于在这两个类之间通信的循环缓冲区和保护它的同步工具是全局变量。

全局变量

const int DataSize = 100000;//生产者生成数据量，使其简单设为常数

const int BufferSize = 8192;//循环缓冲区的大小，这意味着在某个时刻生产者将到达缓冲区的末尾并从头开始。
char buffer[BufferSize];
//为了同步生产者和消费者，我们需要两个等待条件和一个互斥量。
//当生产者生成一些数据时，会发出bufferNotEmpty条件的信号，告诉消费者可以开始读取数据。
//当消费者读取一些数据时,会发出bufferNotFull条件的信号。告诉生产者可以生成更多数据。
//numUsedBytes是缓冲区中包含数据的字节数。
QWaitCondition bufferNotEmpty;
QWaitCondition bufferNotFull;
QMutex mutex;
int numUsedBytes = 0;
//等待条件、互斥锁和numUsedBytes计数器确保生产者永远不会领先于消费者超过BufferSize字节，并且消费者永远不会读取生产者尚未生成的数据。

生产者

class Producer : public QThread
{
public:
    Producer(QObject *parent = NULL) : QThread(parent)
    {
    }

    void run() override
    {
        for (int i = 0; i < DataSize; ++i) {
            mutex.lock();
            if (numUsedBytes == BufferSize)
                bufferNotFull.wait(&mutex);
      //此外，QWaitCondition::wait()函数接受一个互斥对象作为其参数。这个互斥锁在线程进入睡眠状态之前被解锁，在线程醒来时被锁定。
            mutex.unlock();

            buffer[i % BufferSize] = "ACGT"[QRandomGenerator::global()->bounded(4)];
//使用互斥锁来保护对numUsedBytes变量的所有访问。此外，从锁定状态到等待状态的转换是原子性的，以防止竞争条件的发生。
            mutex.lock();
            ++numUsedBytes;
            bufferNotEmpty.wakeAll();
            mutex.unlock();
        }
    }
};

生产者生成DataSize字节的数据。在向循环缓冲区写入字节之前，它必须首先检查缓冲区是否已满（即numUsedBytes等于BufferSize）。如果缓冲区已满，线程将在bufferNotFull条件下等待。
最后，生产者递增numUsedBytes，并发出信号表明条件bufferNotEmpty为true，因为numUsedBBytes必然大于0。

消费者

class Consumer : public QThread
{
    Q_OBJECT
public:
    Consumer(QObject *parent = NULL) : QThread(parent)
    {
    }

    void run() override
    {
        for (int i = 0; i < DataSize; ++i) {
            mutex.lock();
            if (numUsedBytes == 0)
                bufferNotEmpty.wait(&mutex);
            mutex.unlock();

            fprintf(stderr, "%c", buffer[i % BufferSize]);

            mutex.lock();
            --numUsedBytes;
            bufferNotFull.wakeAll();
            mutex.unlock();
        }
        fprintf(stderr, "\n");
    }

signals:
    void stringConsumed(const QString &text);
};

代码与生产者非常相似。在读取字节之前，我们检查缓冲区是否为空（numUsedBytes为0），而不是是否已满，如果为空，则等待bufferNotEmpty条件。读取字节后，我们递减numUsedBytes（而不是递增），并发出bufferNotFull条件（而不是bufferNotEmpty条件）的信号。

主函数

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
    Producer producer;
    Consumer consumer;
    producer.start();
    consumer.start();
    producer.wait();
    consumer.wait();
    return 0;
}

那么，当我们运行程序时会发生什么呢？最初，生产者线程是唯一一个可以做任何事情的线程；消费者被阻止等待bufferNotEmpty条件被发信号通知（numUsedBytes为0）。一旦生产者在缓冲区中放入一个字节，numUsedBytes即为BufferSize-1，并发出bufferNotEmpty条件的信号。在这一点上，可能会发生两件事：要么消费者线程接管并读取该字节，要么生产者产生第二个字节。
此示例中提供的生产者-消费者模型使编写高度并发的多线程应用程序成为可能。在多处理器机器上，该程序的速度可能是等效的基于互斥体的程序的两倍，因为两个线程可以在缓冲区的不同部分同时处于活动状态。
但要注意，这些好处并不总是能实现的。锁定和解锁QMutex是有代价的。在实践中，将缓冲区划分为块并对块而不是单个字节进行操作可能是值得的。缓冲区大小也是一个必须根据实验仔细选择的参数。