QWaitCondition类

QWaitCondition类  

2010-07-14 11:37:38|  分类： Qt|字号 订阅

       QWaitCondition ()

       virtual ~QWaitCondition ()

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

       void wakeOne ()

       void wakeAll ()

       Public function:

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

       1) 释放锁定的mutex

       2) 在线程对象上等待

    mutex必须由调用线程进行初锁定 。注意调用wait的话，会自动调用unlock解锁之前锁住的资源，不然会造成死锁。线程1等待线程2来改变共享资源，从而达到一定的条件然后发出信号，使得线程1从wait中的阻塞状态中被唤醒。但是线程2想改变资源，却无法办到，因为线程1调用lock之后就在wait中blocking，了但是没有及时的unlock，那么这就构成了死锁的条件。所以说wait函数除了使调用线程切换到内核态之外，还自动unlock(&mutex)mutex将被解锁，并且调用线程将会阻塞，直到下列条件之一满足时才醒来：另一个线程使用wakeOne()或wakeAll()传输信号给它。在这种情况下，这个函数将返回真。

time毫秒过去了。如果time为ULONG_MAX（默认值），那么这个等待将永远不会超时（这个事件必须被传输）。如果等待的事件超时，这个函数将会返回假互斥量将以同样的锁定状态返回。这个函数提供的是允许从锁定状态到等待状态的原子转换。

       void QWaitCondition::wakeAll ()

    这将会唤醒所有等待QWaitCondition的线程。这些线程被唤醒的顺序依赖于操组系统的调度策略，并且不能被控制或预知。

       void  QWaitCondition::wakeOne ()

    这将会唤醒所有等待QWaitCondition的线程中的一个线程。这个被唤醒的线程依赖于操组系统的调度策略，并且不能被控制或预知。

    假定每次用户按下一个键，我们有三个任务要同时执行，每个任务都可以放到一个线程中，每个线程的run()都应该是这样：

       QWaitCondition key_pressed;

       for (;;) {

              key_pressed.wait(); // 这是一个QWaitCondition全局变量

              // 键被按下，做一些有趣的事

              do_something();

       }

 

       或是这样：

       forever {

              mutex.lock();

              keyPressed.wait(&mutex);

              do_something();

              mutex.unlock();

       }

 

    第四个线程回去读键按下并且每当它接收到一个的时候唤醒其它三个线程，就像这样：

       QWaitCondition key_pressed;

       for (;;) {

              getchar();

              // 在key_pressed中导致引起任何一个线程。wait()将会从这个方法中返回并继续执行

              key_pressed.wakeAll();

       }

    注意这三个线程被唤醒的顺序是未定义的，并且当键被按下时，这些线程中的一个或多个还在do_something()，它们将不会被唤醒（因为它们现在没有等待条件变量）并且这个任务也就不会针对这次按键执行操作。这种情况是可以避免得，比如，就像下面这样做：

 

       QMutex mymutex;

       QWaitCondition key_pressed;

       int mycount=0;

       //Worker线程代码

       for (;;) {

              key_pressed.wait(); // 这是一个QWaitCondition全局变量

              //keyPressed.wait(&mutex);

              mymutex.lock();

              mycount++;

              mymutex.unlock();

              do_something();

              mymutex.lock();

              mycount--;

              mymutex.unlock();

       }

       // 读取按键线程代码

       for (;;) {

              getchar();

              mymutex.lock();

              // 睡眠，直到没有忙碌的工作线程才醒来。count==0说明没有Worker线程在do something

              while( count > 0 ) {

                     mymutex.unlock();

                     sleep( 1 );

                     mymutex.lock();

              }

              mymutex.unlock();

              key_pressed.wakeAll();

       }

    应用条件变量对前面用信号量进行保护的环状缓冲区的例子进行改进：

下面的例子中：

    1）生产者首先必须检查缓冲是否已满(numUsedBytes==BufferSize)，如果是，线程停下来等待bufferNotFull条件。如果不是，在缓冲中生产数据，增加numUsedBytes,激活条件 bufferNotEmpty。

    2）使用mutex来保护对numUsedBytes的访问。

    另外，QWaitCondition::wait()接收一个mutex作为参数，这个mutex应该被调用线程初始化为锁定状态。在线程进入休眠状态之前，mutex会被解锁。而当线程被唤醒时，mutex会再次处于锁定状态。

    而且，从锁定状态到等待状态的转换是原子操作，这阻止了竞争条件的产生。当程序开始运行时，只有生产者可以工作。消费者被阻塞等待bufferNotEmpty条件，一旦生产者在缓冲中放入一个字节，bufferNotEmpty条件被激发，消费者线程于是被唤醒。

 

       const int DataSize = 100000;

       const int BufferSize = 8192;

       char buffer[BufferSize];

       QWaitCondition bufferNotEmpty;

       QWaitCondition bufferNotFull;

       QMutex mutex;

       int numUsedBytes = 0;

 

       class Producer : public QThread

       {

       public:

              void run();

       };

      

       void Producer::run()

       {

              qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));

              for (int i = 0; i < DataSize; ++i) {

                     mutex.lock();

                     //producer线程首先检查缓冲区是否已满

                     if (numUsedBytes == BufferSize)//缓冲区已满，等待consumer来减少numUsedBytes

                     // bufferNotFull.wait(&mutex)先调用mutex.unlock()然后收到信号时调用mutex.lock()

                     bufferNotFull.wait(&mutex);//缓冲区已满等待bufferNotFull的条件变量成立变为有信号

                     mutex.unlock();

                     buffer[i % BufferSize] = "ACGT"[(int)qrand() % 4];

                     mutex.lock();

                     ++numUsedBytes; //producer用掉一个Bytes，表示producer写入buffer中的字节数

                     bufferNotEmpty.wakeAll();

                     mutex.unlock();

              }

       }

 

       class Consumer : public QThread

       {

       public:

              void run();

       };

 

       void Consumer::run()

       {

              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");

       }

 

       int main(int argc, char *argv[])

       {

              QCoreApplication app(argc, argv);

              Producer producer;

              Consumer consumer;

              producer.start();

              consumer.start();

              producer.wait();

              consumer.wait();

              return 0;

       }

 

 另外一个例子：

 

       #include <qapplication.h>

       #include <qpushbutton.h>

       // 全局条件变量

       QWaitCondition mycond;

       // Worker类实现

       class Worker : public QPushButton, public QThread

       {

       Q_OBJECT

       public:

              Worker(QWidget *parent = 0, const char *name = 0): QPushButton(parent, name)

              {

                     setText("Start Working");

                     // 连接从QPushButton继承来的信号和我们的slotClicked()方法

                     connect(this, SIGNAL(clicked()), SLOT(slotClicked()));

                     // 调用从QThread继承来的start()方法……这将立即开始线程的执行

                     QThread::start();

              }

       public slots:

              void slotClicked()

              {

                     // 唤醒等待这个条件变量的一个线程

                     mycond.wakeOne();

              }

       protected:

              void run()

              {

                     // 这个方法将被新创建的线程调用……

                     while ( TRUE ) {

                            // 锁定应用程序互斥锁，并且设置窗口标题来表明我们正在等待开始工作

                            qApp->lock();

                            setCaption( "Waiting" );

                            qApp->unlock();

                            // 等待直到我们被告知可以继续

                            mycond.wait();

                            // 如果我们到了这里，我们已经被另一个线程唤醒……让我们来设置标题来表明我们正在工作

                            qApp->lock();

                            setCaption( "Working!" );

                            qApp->unlock();

                            // 这可能会占用一些时间，几秒、几分钟或者几小时等等，因为这个一个和GUI线程分开的线程，在处理事件时，GUI线程不会停下来……

                            do_complicated_thing();

                     }

              }

       };

      

       // 主线程——所有的GUI事件都由这个线程处理。

       int main( int argc, char **argv )

       {

              QApplication app( argc, argv );

              // 创建一个worker……当我们这样做的时候，这个worker将在一个线程中运行

              Worker firstworker( 0, "worker" );

              app.setMainWidget( &worker );

              worker.show();

              return app.exec();

       }