Qt 中的多執行緒

轉自：http://www.cppblog.com/yuanyajie/archive/2007/08/22/30599.aspx

QT通過三種形式提供了對執行緒的支援。它們分別是，一、平臺無關的執行緒類，二、執行緒安全的事件投遞，三、跨執行緒的訊號-槽連線。這使得開發輕巧的多執行緒Qt程式更為容易，並能充分利用多處理器機器的優勢。多執行緒程式設計也是一個有用的模式，它用於解決執行較長時間的操作而不至於使用者介面失去響應。在Qt的早期版本中，在構建庫時有不選擇執行緒支援的選項，從4.0開始，執行緒總是有效的。

執行緒類

Qt 包含下面一些執行緒相關的類：
QThread 提供了開始一個新執行緒的方法
QThreadStorage 提供逐執行緒資料儲存
QMutex  提供相互排斥的鎖，或互斥量
QMutexLocker 是一個便利類，它可以自動對QMutex加鎖與解鎖
QReadWriterLock 提供了一個可以同時讀操作的鎖
QReadLocker與QWriteLocker 是便利類，它自動對QReadWriteLock加鎖與解鎖
QSemaphore 提供了一個整型訊號量，是互斥量的泛化
QWaitCondition 提供了一種方法，使得執行緒可以在被另外執行緒喚醒之前一直休眠。

建立一個執行緒

為建立一個執行緒，子類化QThread並且重寫它的run()函式，例如：
class MyThread : public QThread
 {
     Q_OBJECT

 protected:
     void run();
 };

 void MyThread::run()
 {
     ...
 }
之後，建立這個執行緒物件的例項，呼叫QThread::start()。於是，在run()裡出現的程式碼將會在另外執行緒中被執行。
注意：QCoreApplication::exec()必須總是在主執行緒(執行main()的那個執行緒)中被呼叫，不能從一個QThread中呼叫。在GUI程式中，主執行緒也被稱為GUI執行緒，因為它是唯一一個允許執行GUI相關操作的執行緒。另外，你必須在建立一個QThread之前建立QApplication(or QCoreApplication)物件。

執行緒同步

QMutex, QReadWriteLock, QSemaphore,  QWaitCondition 提供了執行緒同步的手段。使用執行緒的主要想法是希望它們可以儘可能併發執行，而一些關鍵點上執行緒之間需要停止或等待。例如，假如兩個執行緒試圖同時訪問同一個全域性變數，結果可能不如所願。
QMutex  提供相互排斥的鎖，或互斥量。在一個時刻至多一個執行緒擁有mutex,假如一個執行緒試圖訪問已經被鎖定的mutex,那麼它將休眠，直到擁有mutex的執行緒對此mutex解鎖。Mutexes常用來保護共享資料訪問。
 QReadWriterLock 與QMutex相似，除了它對 "read","write"訪問進行區別對待。它使得多個讀者可以共時訪問資料。使用QReadWriteLock而不是QMutex，可以使得多執行緒程式更具有併發性。

 QReadWriteLock lock;
 void ReaderThread::run()
 {
    // ...
     lock.lockForRead();
     read_file();
     lock.unlock();
     //...
 }

 void WriterThread::run()
 {
    // ...
     lock.lockForWrite();
     write_file();
     lock.unlock();
    // ...
 }

QSemaphore 是QMutex的一般化，它可以保護一定數量的相同資源，與此相對，一個mutex只保護一個資源。下面例子中，使用QSemaphore來控制對環狀緩衝的訪問，此緩衝區被生產者執行緒和消費者執行緒共享。生產者不斷向緩衝寫入資料直到緩衝末端，再從頭開始。消費者從緩衝不斷讀取資料。訊號量比互斥量有更好的併發性，假如我們用互斥量來控制對緩衝的訪問，那麼生產者，消費者不能同時訪問緩衝。然而，我們知道在同一時刻，不同執行緒訪問緩衝的不同部分並沒有什麼危害。

 const int DataSize = 100000;
 const int BufferSize = 8192;
 char buffer[BufferSize];

 QSemaphore freeBytes(BufferSize);
 QSemaphore usedBytes;

 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) {
         freeBytes.acquire();
         buffer[i % BufferSize] = "ACGT"[(int)qrand() % 4];
         usedBytes.release();
     }
 }

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

 void Consumer::run()
 {
     for (int i = 0; i < DataSize; ++i) {
         usedBytes.acquire();
         fprintf(stderr, "%c", buffer[i % BufferSize]);
         freeBytes.release();
     }
     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;
 }
QWaitCondition 允許執行緒在某些情況發生時喚醒另外的執行緒。一個或多個執行緒可以阻塞等待一QWaitCondition ,用wakeOne()或wakeAll()設定一個條件。wakeOne()隨機喚醒一個，wakeAll()喚醒所有。

下面的例子中，生產者首先必須檢查緩衝是否已滿(numUsedBytes==BufferSize)，如果是，執行緒停下來等待bufferNotFull條件。如果不是，在緩衝中生產資料，增加numUsedBytes,啟用條件 bufferNotEmpty。使用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();
         if (numUsedBytes == BufferSize)
             bufferNotFull.wait(&mutex);
         mutex.unlock();

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

         mutex.lock();
         ++numUsedBytes;
         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;
 }