Qt學習筆記（十）多執行緒
在一個單處理器上執行時，多執行緒應用程式可能會比實現同樣功能的單執行緒應用程式執行的更慢一些，無法體現出其優勢。但在多處理器上執行時，多執行緒應用程式可以在不同的處理器上同時執行多個執行緒，從而獲得更好的整體效能。
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來控制對環狀緩衝的訪問，此緩衝區被生產者執行緒和消費者執行緒共享。生產者不斷向緩衝寫入資料直到緩衝末端，再從頭開始。消費者從緩衝不斷讀取資料。訊號量比互斥量有更好的併發性，假如我們用互斥量來控制對緩衝的訪問，那麼生產者，消費者不能同時訪問緩衝。然而，我們知道在同一時刻，不同執行緒訪問緩衝的不同部分並沒有什麼危害。
constint DataSize =100000;constint 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();
return0;
}
QWaitCondition 允許執行緒在某些情況發生時喚醒另外的執行緒。一個或多個執行緒可以阻塞等待一QWaitCondition ,用wakeOne()或wakeAll()設定一個條件。wakeOne()隨機喚醒一個，wakeAll()喚醒所有。
下面的例子中，生產者首先必須檢查緩衝是否已滿(numUsedBytes==BufferSize)，如果是，執行緒停下來等待bufferNotFull條件。如果不是，在緩衝中生產資料，增加numUsedBytes,啟用條件 bufferNotEmpty。使用mutex來保護對numUsedBytes的訪問。另外，QWaitCondition::wait()接收一個mutex作為引數，這個mutex應該被呼叫執行緒初始化為鎖定狀態。線上程進入休眠狀態之前，mutex會被解鎖。而當執行緒被喚醒時，mutex會處於鎖定狀態,而且，從鎖定狀態到等待狀態的轉換是原子操作，這阻止了競爭條件的產生。當程式開始執行時，只有生產者可以工作。消費者被阻塞等待bufferNotEmpty條件，一旦生產者在緩衝中放入一個位元組，bufferNotEmpty條件被激發，消費者執行緒於是被喚醒。
constint DataSize =100000;constint 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");
}
bool QWaitCondition::wait ( unsigned long time = ULONG_MAX )
線上程事件物件上等待。呼叫這個的執行緒將會阻塞，直到下列條件之一滿足時才醒來：- 另一個執行緒使用wakeOne()或wakeAll()傳輸訊號給它。在這種情況下，這個函式將返回真。
- time毫秒過去了。如果time為ULONG_MAX（預設值），那麼這個等待將永遠不會超時（這個事件必須被傳輸）。如果等待的事件超時，這個函式將會返回假。
bool QWaitCondition::wait ( QMutex * mutex, unsigned long time = ULONG_MAX )
這是一個過載成員函式，提供了方便。它的行為基本上和上面的函式相同。釋放鎖定的mutex並且線上程事件物件上等待。mutex必須由呼叫執行緒初始鎖定的。如果mutex沒有在鎖定狀態，這個函式立即返回。如果mutex是一個遞迴互斥量，這個函式立即返回。mutex將被解鎖，並且呼叫執行緒將會阻塞，直到下列條件之一滿足時才醒來：
- 另一個執行緒使用wakeOne()或wakeAll()傳輸訊號給它。在這種情況下，這個函式將返回真。
- time毫秒過去了。如果time為ULONG_MAX（預設值），那麼這個等待將永遠不會超時（這個事件必須被傳輸）。如果等待的事件超時，這個函式將會返回假。
互斥量將以同樣的鎖定狀態返回。這個函式提供的是允許從鎖定狀態到等待狀態的原子轉換。
int main(int argc, char*argv[])
{
QCoreApplication app(argc, argv);
Producer producer;
Consumer consumer;
producer.start();
consumer.start();
producer.wait();
consumer.wait();
return0;
}
與主執行緒通訊
當QT應用程式開始執行時，只有主執行緒是執行的。主執行緒是唯一允許建立QApplication或者QCoreApplication物件，並且可以對建立的物件呼叫exec()的執行緒。在呼叫exec()之後，這個執行緒或者等待一個事件或者處理一個事件。
通過建立一些QThread子類的物件，主執行緒可以開始一些新的執行緒。如果這些執行緒需要在他們之間進行通訊，則可以使用含有互斥量、讀寫鎖、訊號或者等待條件的共享變數。但在這些技術中，沒有任何一個可以用來和主執行緒進行通訊，因為他們會鎖住事件迴圈並且會凍結使用者介面。
在子執行緒和主執行緒之間進行通訊的一個解決方案是線上程之間使用訊號---槽的連線。通常情況下，訊號和槽機制可以同步操作，這意味著在發射訊號的時候，使用直接函式即可立刻呼叫連線到一個訊號上的多個槽。然而，當連線位於不同執行緒中的物件時，這一機制就會變得不同步起來【這種狀態可以通過修改QObject::connect()中的第五個可選引數而改變】。這個槽接著就會由執行緒的事件迴圈呼叫，而在該執行緒中存在著接收器物件。在預設情況下，QObject存在於建立它的執行緒中，通過呼叫QObject::moveToThread()可以在任意時刻修改它。
在子執行緒中使用QT類
當函式可以同時被不同的執行緒安全的呼叫時，被稱為”執行緒安全“的。如果在不同的執行緒中對某一共享資料局同時呼叫兩個執行緒安全的函式，那麼結果就總是確定的。當一個類的所有函式都可以同時被不同的執行緒呼叫，並且他們之間互不干涉，即使想在操作同一個物件的時候也互不妨礙，則稱這個類是”執行緒安全“的。
在Qt中，執行緒安全的類有 QMutex, QMutexLocker, QReadWriteLock, QReadLock, QWriteLock, QSemaphore, QThreadStorage<T>以及QWaitCondition。此外，部分QThread應用程式設計介面和其他某些函式也是執行緒安全的，特別是QObject::connect(), QObject::disconnect(), QCoreApplication::postEvent(), QCoreApplication::removePostedEvent()。
可重入與執行緒安全
在Qt文件中，術語“可重入”與“執行緒安全”被用來說明一個函式如何用於多執行緒程式。假如一個類的任何函式在此類的多個不同的例項上，可以被多個執行緒同時呼叫，那麼這個類被稱為是“可重入”的。假如不同的執行緒作用在同一個例項上仍可以正常工作，那麼稱之為“執行緒安全”的。
c++中類的不同物件的成員變數是獨立的，成員函式是共享的。在使用成員函式對成員變數進行操作時，系統能夠知道操作的具體是哪個物件，是因為成員函式含有隱含的引數this指標。
可重入：
可重入函式也可以這樣理解，重入即表示重複進入，首先它意味著這個函式可以被中斷，其次意味著它除了使用自己棧上的變數以外不依賴於任何環境（包括static），這樣的函式就是purecode（純程式碼）可重入，可以允許有該函式的多個副本在執行，由於它們使用的是分離的棧，所以不會互相干擾。如果確實需要訪問全域性變數（包括static），一定要注意實施互斥手段。可重入函式在並行執行環境中非常重要，但是一般要為訪問全域性變數付出一些效能代價。
編寫可重入函式時，若使用全域性變數，則應通過關中斷、訊號量（即P、V操作）等手段對其加以保護。 若對所使用的全域性變數不加以保護，則此函式就不具有可重入性，即當多個程序呼叫此函式時，很有可能使有關全域性變數變為不可知狀態。 在實時系統的設計中，經常會出現多個任務呼叫同一個函式的情況。如果這個函式不幸被設計成為不可重入的函式的話，那麼不同任務呼叫這個函式時可能修改其他任務呼叫這個函式的資料，從而導致不可預料的後果。那麼什麼是可重入函式呢？所謂可重入函式是指一個可以被多個任務呼叫的過程，任務在呼叫時不必擔心資料是否會出錯。不可重入函式在實時系統設計中被視為不安全函式。執行緒安全：
如果你的程式碼所在的程序中有多個執行緒在同時執行，而這些執行緒可能會同時執行這段程式碼。如果每次執行結果和單執行緒執行的結果是一樣的，而且其他的變數的值也和預期的是一樣的，就是執行緒安全的。 或者說:一個類或者程式所提供的介面對於執行緒來說是原子操作或者多個執行緒之間的切換不會導致該介面的執行結果存在二義性,也就是說我們不用考慮同步的問題。 執行緒安全問題都是由全域性變數及靜態變數引起的。
若每個執行緒中對全域性變數、靜態變數只有讀操作，而無寫操作，一般來說，這個全域性變數是執行緒安全的；若有多個執行緒同時執行寫操作，一般都需要考慮執行緒同步，否則的話就可能影響執行緒安全。
大多數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()。以使得它修改不會對別的共享者產生影響，既然修改後的資料與原來的那份資料不同了，因此不可能再共享了，於是它先執行深拷貝，把資料取回來，再在這份資料上進行修改。例如：