本文介紹的是了解 Qt 多線程編程，本文并沒有過多的去總結多線程的概念，通過了解線程類和一些線程的實現，去真正的弄清楚。首先，我們先來 看文章的講解。

概述

QT通過三種形式提供了對線程的支持。它們分別是，一、平臺無關的線程類，二、線程安全的事件投遞，三、跨線程的信號-槽連接。這使得開發輕巧的多線程 Qt程序更為容易，并能充分利用多處理器機器的優勢。多線程編程也是一個有用的模式，它用于解決執行較長時間的操作而不至于用戶界面失去響應。

Qt 線程類

Qt 包含下面一些線程相關的類：

QThread 提供了開始一個新線程的方法

QThreadStorage 提供逐線程數據存儲

QMutex 提供相互排斥的鎖，或互斥量

QMutexLocker 是一個便利類，它可以自動對QMutex加鎖與解鎖

QReadWriterLock 提供了一個可以同時讀操作的鎖

QReadLocker與QWriteLocker 是便利類，它自動對QReadWriteLock加鎖與解鎖

QSemaphore 提供了一個整型信號量，是互斥量的泛化

QWaitCondition 提供了一種方法，使得線程可以在被另外線程喚醒之前一直休眠。

Qt 高級線程類

QtConcurrent 開啟線程事務

QFutureWatcher 觀測線程狀態

QFuture 線程啟動類

QThread創建線程

為創建一個線程，子類化QThread并且重寫它的run()函數，例如：

class MyThread : public QThread  
 {  
     Q_OBJECT  
 protected:  
     void run();  
 };  
 void MyThread::run()  
 {  
     ...  
 } 

之后調用start，Qt即可創建一個線程，并在線程中執行run()函數中代碼，注意UI非線程安全的。

QtConcurrent創建線程

QtConcurrent 創建線程的方法比較多， 而且QtConcurrent 本身比較特殊，若系統有空閑線程時，它會調度空閑線程，無空閑線程時將會創建一個線程。（注意：QtConcurrent 創建線程歸QthreadPool管理，若超過***線程數，將會進入隊列等待），QtConcurrent創建線程的方法多種，以下舉例map函數：

QImage scale(const QImage &image)  
 {  
     qDebug() < < "Scaling image in thread" << QThread::currentThread();  
     return image.scaled(QSize(100, 100), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);  
 }  
 
 int main(int argc, char *argv[])  
 {  
     QApplication app(argc, argv);  
 
     const int imageCount = 20;  
 
     // Create a list containing imageCount images.  
     QList images;  
     for (int i = 0; i < imageCount; ++i)  
         images.append(QImage(1600, 1200, QImage::Format_ARGB32_Premultiplied));  
 
     // Use QtConcurrentBlocking::mapped to apply the scale function to all the  
     // images in the list.  
     QList thumbnails = QtConcurrent::blockingMapped(images, scale);  
 
     return 0;  
 } 

#p#

Qt 線程同步

QMutex, QReadWriteLock, QSemaphore, QWaitCondition 提供了線程同步的手段。使用線程的主要想法是希望它們可以盡可能并發執行，而一些關鍵點上線程之間需要停止或等待。例如，假如兩個線程試圖同時訪問同一個 全局變量，結果可能不如所愿。

QMutex

QMutex 提供相互排斥的鎖，或互斥量。在一個時刻至多一個線程擁有mutex,假如一個線程試圖訪問已經被鎖定的mutex,那么它將休眠，直到擁有mutex的線程對此mutex解鎖。Mutexes常用來保護共享數據訪問。

QReadWriterLock

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

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;  
 }  

#p#

QWaitCondition

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;  
 } 

小結：對于Qt 中多線程編程的介紹就到這了，希望本篇文章對你有所幫助。