程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> C語言 >> C >> 關於C >> Qt學習 之 多線程程序設計

Qt學習 之 多線程程序設計

編輯:關於C

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

可重入與線程安全

在Qt文檔中,術語“可重入”與“線程安全”被用來說明一個函數如何用於多線程程序。假如一個類的任何函數在此類的多個不同的實例上,可以被多個線程同時調用,那麼這個類被稱為是“可重入”的。假如不同的線程作用在同一個實例上仍可以正常工作,那麼稱之為“線程安全”的。
大多數c++類天生就是可重入的,因為它們典型地僅僅引用成員數據。任何線程可以在類的一個實例上調用這樣的成員函數,只要沒有別的線程在同一個實例上調用這個成員函數。舉例來講,下面的Counter 類是可重入的:

class Counter
{
public:
      Counter() {n=0;}
      void increment() {++n;}
      void decrement() {--n;}
      int value() const {return n;}
private:
      int n;
};

這個類不是線程安全的,因為假如多個線程都試圖修改數據成員 n,結果未定義。這是因為c++中的++和–操作符不是原子操作。實際上,它們會被擴展為三個機器指令:

1,把變量值裝入寄存器
2,增加或減少寄存器中的值
3,把寄存器中的值寫回內存

假如線程A與B同時裝載變量的舊值,在寄存器中增值,回寫。他們寫操作重疊了,導致變量值僅增加了一次。很明顯,訪問應該串行化:A執行123步驟時不應被打斷。使這個類成為線程安全的最簡單方法是使用QMutex來保護數據成員:

class Counter
{
public:
     Counter() { n = 0; }
     void increment() { QMutexLocker locker(&mutex); ++n; }
     void decrement() { QMutexLocker locker(&mutex); --n; }
     int value() const { QMutexLocker locker(&mutex); return n; }
private:
     mutable QMutex mutex;
     int n;
};

QMutexLocker類在構造函數中自動對mutex進行加鎖,在析構函數中進行解鎖。隨便一提的是,mutex使用了mutable關鍵字來修飾,因為我們在value()函數中對mutex進行加鎖與解鎖操作,而value()是一個const函數。
大多數Qt類是可重入,非線程安全的。有一些類與函數是線程安全的,它們主要是線程相關的類,如QMutex,QCoreApplication::postEvent()。

線程與QObjects

QThread 繼承自QObject,它發射信號以指示線程執行開始與結束,而且也提供了許多slots。更有趣的是,QObjects可以用於多線程,這是因為每個線程被允許有它自己的事件循環。
QObject 可重入性
QObject是可重入的。它的大多數非GUI子類,像QTimer,QTcpSocket,QUdpSocket,QHttp,QFtp,QProcess也是可重入的,在多個線程中同時使用這些類是可能的。需要注意的是,這些類被設計成在一個單線程中創建與使用,因此,在一個線程中創建一個對象,而在另外的線程中調用它的函數,這樣的行為不能保證工作良好。有三種約束需要注意:
1,QObject的孩子總是應該在它父親被創建的那個線程中創建。這意味著,你絕不應該傳遞QThread對象作為另一個對象的父親(因為QThread對象本身會在另一個線程中被創建)
2,事件驅動對象僅僅在單線程中使用。明確地說,這個規則適用於”定時器機制“與”網格模塊“,舉例來講,你不應該在一個線程中開始一個定時器或是連接一個套接字,當這個線程不是這些對象所在的線程。
3,你必須保證在線程中創建的所有對象在你刪除QThread前被刪除。這很容易做到:你可以run()函數運行的棧上創建對象。

盡管QObject是可重入的,但GUI類,特別是QWidget與它的所有子類都是不可重入的。它們僅用於主線程。正如前面提到過的,QCoreApplication::exec()也必須從那個線程中被調用。實踐上,不會在別的線程中使用GUI類,它們工作在主線程上,把一些耗時的操作放入獨立的工作線程中,當工作線程運行完成,把結果在主線程所擁有的屏幕上顯示。

逐線程事件循環

每個線程可以有它的事件循環,初始線程開始它的事件循環需使用QCoreApplication::exec(),別的線程開始它的事件循環需要用QThread::exec().像QCoreApplication一樣,QThreadr提供了exit(int)函數,一個quit() slot。

線程中的事件循環,使得線程可以使用那些需要事件循環的非GUI 類(如,QTimer,QTcpSocket,QProcess)。也可以把任何線程的signals連接到特定線程的slots,也就是說信號-槽機制是可以跨線程使用的。對於在QApplication之前創建的對象,QObject::thread()返回0,這意味著主線程僅為這些對象處理投遞事件,不會為沒有所屬線程的對象處理另外的事件。可以用QObject::moveToThread()來改變它和它孩子們的線程親緣關系,假如對象有父親,它不能移動這種關系。在另一個線程(而不是創建它的那個線程)中delete QObject對象是不安全的。除非你可以保證在同一時刻對象不在處理事件。可以用QObject::deleteLater(),它會投遞一個DeferredDelete事件,這會被對象線程的事件循環最終選取到。

假如沒有事件循環運行,事件不會分發給對象。舉例來說,假如你在一個線程中創建了一個QTimer對象,但從沒有調用過exec(),那麼QTimer就不會發射它的timeout()信號.對deleteLater()也不會工作。(這同樣適用於主線程)。你可以手工使用線程安全的函數QCoreApplication::postEvent(),在任何時候,給任何線程中的任何對象投遞一個事件,事件會在那個創建了對象的線程中通過事件循環派發。事件過濾器在所有線程中也被支持,不過它限定被監視對象與監視對象生存在同一線程中。類似地,QCoreApplication::sendEvent(不是postEvent()),僅用於在調用此函數的線程中向目標對象投遞事件。

從別的線程中訪問QObject子類

QObject和所有它的子類是非線程安全的。這包括整個的事件投遞系統。需要牢記的是,當你正從別的線程中訪問對象時,事件循環可以向你的QObject子類投遞事件。假如你調用一個不生存在當前線程中的QObject子類的函數時,你必須用mutex來保護QObject子類的內部數據,否則會遭遇災難或非預期結果。像其它的對象一樣,QThread對象生存在創建它的那個線程中—不是當QThread::run()被調用時創建的那個線程。一般來講,在你的QThread子類中提供slots是不安全的,除非你用mutex保護了你的成員變量。

另一方面,你可以安全的從QThread::run()的實現中發射信號,因為信號發射是線程安全的。

跨線程的信號-槽

Qt支持三種類型的信號-槽連接:

1,直接連接,當signal發射時,slot立即調用。此slot在發射signal的那個線程中被執行(不一定是接收對象生存的那個線程)
2,隊列連接,當控制權回到對象屬於的那個線程的事件循環時,slot被調用。此slot在接收對象生存的那個線程中被執行
3,自動連接(缺省),假如信號發射與接收者在同一個線程中,其行為如直接連接,否則,其行為如隊列連接。

連接類型可能通過以向connect()傳遞參數來指定。注意的是,當發送者與接收者生存在不同的線程中,而事件循環正運行於接收者的線程中,使用直接連接是不安全的。同樣的道理,調用生存在不同的線程中的對象的函數也是不是安全的。QObject::connect()本身是線程安全的。

多線程與隱含共享

Qt為它的許多值類型使用了所謂的隱含共享(implicit sharing)來優化性能。原理比較簡單,共享類包含一個指向共享數據塊的指針,這個數據塊中包含了真正原數據與一個引用計數。把深拷貝轉化為一個淺拷貝,從而提高了性能。這種機制在幕後發生作用,程序員不需要關心它。如果深入點看,假如對象需要對數據進行修改,而引用計數大於1,那麼它應該先detach()。以使得它修改不會對別的共享者產生影響,既然修改後的數據與原來的那份數據不同了,因此不可能再共享了,於是它先執行深拷貝,把數據取回來,再在這份數據上進行修改。例如:

void QPen::setStyle(Qt::PenStyle style)
{
     detach();           // detach from common data
     d->style = style;   // set the style member
}
void QPen::detach()
{
     if (d->ref != 1) {
         ...             // perform a deep copy
     }
}

一般認為,隱含共享與多線程不太和諧,因為有引用計數的存在。對引用計數進行保護的方法之一是使用mutex,但它很慢,Qt早期版本沒有提供一個滿意的解決方案。從4.0開始,隱含共享類可以安全地跨線程拷貝,如同別的值類型一樣。它們是完全可重入的。隱含共享真的是”implicit”。它使用匯編語言實現了原子性引用計數操作,這比用mutex快多了。
假如你在多個線程中同進訪問相同對象,你也需要用mutex來串行化訪問順序,就如同其他可重入對象那樣。總的來講,隱含共享真的給”隱含“掉了,在多線程程序中,你可以把它們看成是一般的,非共享的,可重入的類型,這種做法是安全的。


  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved