一、線程基礎(chǔ)

1、GUI線程與工作線程

每個程序啟動后擁有的第一個線程稱為主線程，即GUI線程。QT中所有的組件類和幾個相關(guān)的類只能工作在GUI線程，不能工作在次線程，次線程即工作線程，主要負(fù)責(zé)處理GUI線程卸下的工作。

2、數(shù)據(jù)的同步訪問

每個線程都有自己的棧，因此每個線程都要自己的調(diào)用歷史和本地變量。線程共享相同的地址空間。

二、QT多線程簡介

QT通過三種形式提供了對線程的支持，分別是平臺無關(guān)的線程類、線程安全的事件投遞、跨線程的信號-槽連接。
QT中線程類包含如下：

• QThread 提供了跨平臺的多線程解決方案
• QThreadStorage 提供逐線程數(shù)據(jù)存儲
• QMutex 提供相互排斥的鎖，或互斥量
• QMutexLocker 是一個輔助類，自動對 QMutex 加鎖與解鎖
• QReadWriterLock 提供了一個可以同時讀操作的鎖
• QReadLocker與QWriteLocker 自動對QReadWriteLock 加鎖與解鎖
• QSemaphore 提供了一個整型信號量，是互斥量的泛化
• QWaitCondition 提供了一種方法，使得線程可以在被另外線程喚醒之前一直休眠。

三、QThread線程

1、QThread線程基礎(chǔ)

    QThread是Qt線程中有一個公共的抽象類，所有的線程類都是從QThread抽象類中派生的，需要實現(xiàn)QThread中的虛函數(shù)run(),通過start()函數(shù)來調(diào)用run函數(shù)。
    void run（）函數(shù)是線程體函數(shù)，用于定義線程的功能。
    void start（）函數(shù)是啟動函數(shù)，用于將線程入口地址設(shè)置為run函數(shù)。
    void terminate（）函數(shù)用于強制結(jié)束線程，不保證數(shù)據(jù)完整性和資源釋放。
    QCoreApplication::exec()總是在主線程(執(zhí)行main()的線程)中被調(diào)用，不能從一個QThread中調(diào)用。在GUI程序中，主線程也稱為GUI線程，是唯一允許執(zhí)行GUI相關(guān)操作的線程。另外，必須在創(chuàng)建一個QThread前創(chuàng)建QApplication(or QCoreApplication)對象。
    當(dāng)線程啟動和結(jié)束時，QThread會發(fā)送信號started()和finished()，可以使用isFinished()和isRunning()來查詢線程的狀態(tài)。
    從Qt4.8起，可以釋放運行剛剛結(jié)束的線程對象，通過連接finished()信號到QObject::deleteLater()槽。
    使用wait()來阻塞調(diào)用的線程，直到其它線程執(zhí)行完畢（或者直到指定的時間過去）。
    靜態(tài)函數(shù)currentThreadId()和currentThread()返回標(biāo)識當(dāng)前正在執(zhí)行的線程。前者返回線程的ID，后者返回一個線程指針。
    要設(shè)置線程的名稱，可以在啟動線程之前調(diào)用setObjectName()。如果不調(diào)用setObjectName()，線程的名稱將是線程對象的運行時類型（QThread子類的類名）。

2、線程的優(yōu)先級

    QThread線程總共有8個優(yōu)先級

    QThread::IdlePriority   0 scheduled only when no other threads are running.
    QThread::LowestPriority  1 scheduled less often than LowPriority.
    QThread::LowPriority   2 scheduled less often than NormalPriority.
    QThread::NormalPriority  3 the default priority of the operating system.
    QThread::HighPriority   4 scheduled more often than NormalPriority.
    QThread::HighestPriority  5 scheduled more often than HighPriority.
    QThread::TimeCriticalPriority 6 scheduled as often as possible.
    QThread::InheritPriority   7 use the same priority as the creating thread. This is the default.
    void setPriority(Priority priority) 

    設(shè)置正在運行線程的優(yōu)先級。如果線程沒有運行，此函數(shù)不執(zhí)行任何操作并立即返回。使用的start()來啟動一個線程具有特定的優(yōu)先級。優(yōu)先級參數(shù)可以是QThread::Priority枚舉除InheritPriortyd的任何值。

3、線程的創(chuàng)建

 void start ( Priority priority = InheritPriority )

啟動線程執(zhí)行，啟動后會發(fā)出started ()信號

4、線程的執(zhí)行

int exec() [protected] 

進入事件循環(huán)并等待直到調(diào)用exit()，返回值是通過調(diào)用exit()來獲得，如果調(diào)用成功則返回0。

void run() [virtual protected] 

線程的起點，在調(diào)用start()之后，新創(chuàng)建的線程就會調(diào)用run函數(shù)，默認(rèn)實現(xiàn)調(diào)用exec()，大多數(shù)需要重新實現(xiàn)run函數(shù)，便于管理自己的線程。run函數(shù)返回時，線程的執(zhí)行將結(jié)束。

5、線程的退出

void quit();

通知線程事件循環(huán)退出，返回0表示成功，相當(dāng)于調(diào)用了QThread::exit(0)。

void exit ( int returnCode = 0 );

調(diào)用exit后，thread將退出event loop，并從exec返回，exec的返回值就是returnCode。通常returnCode=0表示成功，其他值表示失敗。

void terminate ();

結(jié)束線程，線程是否立即終止取決于操作系統(tǒng)。

線程被終止時，所有等待該線程Finished的線程都將被喚醒。

terminate是否調(diào)用取決于setTerminationEnabled ( bool enabled = true )開關(guān)。

void requestInterruption() 

請求線程的中斷。請求是咨詢意見并且取決于線程上運行的代碼，來決定是否及如何執(zhí)行這樣的請求。此函數(shù)不停止線程上運行的任何事件循環(huán)，并且在任何情況下都不會終止它。

工程中線程退出的解決方案如下：

通過在線程類中增加標(biāo)識變量volatile bool m_stop,通過m_stop變量的值判斷run函數(shù)是否執(zhí)行結(jié)束返回。

#ifndef WORKTHREAD_H
#define WORKTHREAD_H
#include <QThread>
#include <QDebug>
class WorkThread : public QThread
{
protected:
  //線程退出的標(biāo)識量
  volatile bool m_stop;
  void run()
  {
    qDebug() << "run begin";
    while(!m_stop)
    {
        //task handling
        int* p = new int[1000];
        for(int i = 0; i < 1000; i++)
        {
            p[i] = i * i;
        }
        sleep(2);
        delete [] p;
    }
    qDebug() << "run end";
  }
public:
  WorkThread()
    m_stop = false;
  //線程退出的接口函數(shù)，用戶使用
  void stop()
    m_stop = true;
};
#endif // WORKTHREAD_H

6、線程的等待

bool wait ( unsigned long time = ULONG_MAX )

線程將會被阻塞，等待time毫秒,如果線程退出，則wait會返回。Wait函數(shù)解決多線程在執(zhí)行時序上的依賴。

void msleep ( unsigned long msecs )
void sleep ( unsigned long secs )
void usleep ( unsigned long usecs )

sleep()、msleep()、usleep()允許秒，毫秒和微秒來區(qū)分，但在Qt5.0中被設(shè)為public。

一般情況下，wait()和sleep()函數(shù)應(yīng)該不需要，因為Qt是一個事件驅(qū)動型框架?？紤]監(jiān)聽finished()信號來取代wait()，使用QTimer來取代sleep()。

7、線程的狀態(tài)

bool isFinished () const  線程是否已經(jīng)退出
bool isRunning () const   線程是否處于運行狀態(tài)

8、線程的屬性

Priority priority () const
void setPriority ( Priority priority )
uint stackSize () const
void setStackSize ( uint stackSize )
void setTerminationEnabled ( bool enabled = true )

設(shè)置是否響應(yīng)terminate()函數(shù)

9、線程與事件循環(huán)

    QThread中run()的默認(rèn)實現(xiàn)調(diào)用了exec()，從而創(chuàng)建一個QEventLoop對象，由QEventLoop對象處理線程中事件隊列（每一個線程都有一個屬于自己的事件隊列）中的事件。exec()在其內(nèi)部不斷做著循環(huán)遍歷事件隊列的工作，調(diào)用QThread的quit()或exit()方法使退出線程，盡量不要使用terminate()退出線程，terminate()退出線程過于粗暴，造成資源不能釋放，甚至互斥鎖還處于加鎖狀態(tài)。

    線程中的事件循環(huán)，使得線程可以使用那些需要事件循環(huán)的非GUI 類(如，QTimer,QTcpSocket,QProcess)。

    在QApplication前創(chuàng)建的對象，QObject::thread()返回NULL,意味著主線程僅為這些對象處理投遞事件，不會為沒有所屬線程的對象處理另外的事件?？梢杂肣Object::moveToThread()來改變對象及其子對象的線程親緣關(guān)系，假如對象有父親，不能移動這種關(guān)系。在另一個線程(而不是創(chuàng)建它的線程)中delete QObject對象是不安全的。除非可以保證在同一時刻對象不在處理事件?？梢杂肣Object::deleteLater(),它會投遞一個DeferredDelete事件，這會被對象線程的事件循環(huán)最終選取到。假如沒有事件循環(huán)運行，事件不會分發(fā)給對象。假如在一個線程中創(chuàng)建了一個QTimer對象，但從沒有調(diào)用過exec(),那么QTimer就不會發(fā)射它的timeout()信號，deleteLater()也不會工作?？梢允止な褂镁€程安全的函數(shù)QCoreApplication::postEvent()，在任何時候，給任何線程中的任何對象投遞一個事件，事件會在那個創(chuàng)建了對象的線程中通過事件循環(huán)派發(fā)。事件過濾器在所有線程中也被支持，不過它限定被監(jiān)視對象與監(jiān)視對象生存在同一線程中。QCoreApplication::sendEvent(不是postEvent()),僅用于在調(diào)用此函數(shù)的線程中向目標(biāo)對象投遞事件。

四、線程的同步

1、線程同步基礎(chǔ)

    臨界資源：每次只允許一個線程進行訪問的資源
    線程間互斥：多個線程在同一時刻都需要訪問臨界資源
    線程鎖能夠保證臨界資源的安全性，通常，每個臨界資源需要一個線程鎖進行保護。
    線程死鎖：線程間相互等待臨界資源而造成彼此無法繼續(xù)執(zhí)行。
    產(chǎn)生死鎖的條件：
    A、系統(tǒng)中存在多個臨界資源且臨界資源不可搶占
    B、線程需要多個臨界資源才能繼續(xù)執(zhí)行
    死鎖的避免：
    A、對使用的每個臨界資源都分配一個唯一的序號
    B、對每個臨界資源對應(yīng)的線程鎖分配相應(yīng)的序號
    C、系統(tǒng)中的每個線程按照嚴(yán)格遞增的次序請求臨界資源
    QMutex, QReadWriteLock, QSemaphore, QWaitCondition 提供了線程同步的手段。使用線程的主要想法是希望它們可以盡可能并發(fā)執(zhí)行，而一些關(guān)鍵點上線程之間需要停止或等待。例如，假如兩個線程試圖同時訪問同一個全局變量，結(jié)果可能不如所愿。

2、互斥量QMutex

    QMutex 提供相互排斥的鎖，或互斥量。在一個時刻至多一個線程擁有mutex,假如一個線程試圖訪問已經(jīng)被鎖定的mutex,那么線程將休眠，直到擁有mutex的線程對此mutex解鎖。QMutex常用來保護共享數(shù)據(jù)訪問。QMutex類所以成員函數(shù)是線程安全的。

頭文件聲明：    #include <QMutex>
互斥量聲明：    QMutex m_Mutex;
互斥量加鎖：    m_Mutex.lock();
互斥量解鎖：    m_Mutex.unlock();

如果對沒有加鎖的互斥量進行解鎖，結(jié)果是未定義的?；コ饬康募渔i和解鎖必須在同一線程中成對出現(xiàn)。

QMutex ( RecursionMode mode = NonRecursive )

QMutex有兩種模式：Recursive, NonRecursive

A、Recursive
    一個線程可以對mutex多次lock，直到相應(yīng)次數(shù)的unlock調(diào)用后，mutex才真正被解鎖。

B、NonRecursive
    默認(rèn)模式，mutex只能被lock一次。
    如果使用了Mutex.lock()而沒有對應(yīng)的使用Mutex.unlcok()的話就會造成死鎖，其他的線程將永遠(yuǎn)也得不到接觸Mutex鎖住的共享資源的機會。盡管可以不使用lock()而使用tryLock(timeout)來避免因為死等而造成的死鎖( tryLock(負(fù)值)==lock()),但是還是很有可能造成錯誤。

    bool tryLock();
    如果當(dāng)前其他線程已對該mutex加鎖，則該調(diào)用會立即返回，而不被阻塞。
    bool tryLock(int timeout);
    如果當(dāng)前其他線程已對該mutex加鎖，則該調(diào)用會等待一段時間，直到超時

QMutex mutex;
int complexFunction(int flag)
 {
     mutex.lock();
     int retVal = 0;
     switch (flag) {
     case 0:
     case 1:
         mutex.unlock();
         return moreComplexFunction(flag);
     case 2:
         {
             int status = anotherFunction();
             if (status < 0) {
                 mutex.unlock();
                 return -2;
             }
             retVal = status + flag;
         }
         break;
     default:
         if (flag > 10) {
             mutex.unlock();
             return -1;
     }
     mutex.unlock();
     return retVal;
 }

3、互斥鎖QMutexLocker

    在較復(fù)雜的函數(shù)和異常處理中對QMutex類mutex對象進行l(wèi)ock()和unlock()操作將會很復(fù)雜，進入點要lock()，在所有跳出點都要unlock()，很容易出現(xiàn)在某些跳出點未調(diào)用unlock()，所以Qt引進了QMutex的輔助類QMutexLocker來避免lock()和unlock()操作。在函數(shù)需要的地方建立QMutexLocker對象，并把mutex指針傳給QMutexLocker對象，此時mutex已經(jīng)加鎖，等到退出函數(shù)后，QMutexLocker對象局部變量會自己銷毀，此時mutex解鎖。
頭文件聲明：    #include<QMutexLocker>
互斥鎖聲明：    QMutexLocker mutexLocker(&m_Mutex);
互斥鎖加鎖：    從聲明處開始（在構(gòu)造函數(shù)中加鎖）
互斥鎖解鎖：    出了作用域自動解鎖（在析構(gòu)函數(shù)中解鎖）

 int complexFunction(int flag)
     QMutexLocker locker(&mutex);
             if (status < 0)
         if (flag > 10)

4、QReadWriteLock

    QReadWriterLock 與QMutex相似，但對讀寫操作訪問進行區(qū)別對待，可以允許多個讀者同時讀數(shù)據(jù)，但只能有一個寫，并且寫讀操作不同同時進行。使用QReadWriteLock而不是QMutex，可以使得多線程程序更具有并發(fā)性。 QReadWriterLock默認(rèn)模式是NonRecursive。

QReadWriterLock類成員函數(shù)如下：

QReadWriteLock ( )
QReadWriteLock ( RecursionMode recursionMode )
void lockForRead ()
void lockForWrite ()
bool tryLockForRead ()
bool tryLockForRead ( int timeout )
bool tryLockForWrite ()
bool tryLockForWrite ( int timeout )
boid unlock ()
使用實例：
QReadWriteLock lock;
 void ReaderThread::run()
     lock.lockForRead();
     read_file();
     lock.unlock();
 void WriterThread::run()
     lock.lockForWrite();
     write_file();

5、QReadLocker和QWriteLocker

    在較復(fù)雜的函數(shù)和異常處理中對QReadWriterLock類lock對象進行l(wèi)ockForRead()/lockForWrite()和unlock()操作將會很復(fù)雜，進入點要lockForRead()/lockForWrite()，在所有跳出點都要unlock()，很容易出現(xiàn)在某些跳出點未調(diào)用unlock()，所以Qt引進了QReadLocker和QWriteLocker類來簡化解鎖操作。在函數(shù)需要的地方建立QReadLocker或QWriteLocker對象，并把lock指針傳給QReadLocker或QWriteLocker對象，此時lock已經(jīng)加鎖，等到退出函數(shù)后，QReadLocker或QWriteLocker對象局部變量會自己銷毀，此時lock解鎖。

 QByteArray readData()
     ...
     return data;

使用QReadLocker：

 QReadLocker locker(&lock);

6、信號量QSemaphore

    QSemaphore 是QMutex的一般化，是特殊的線程鎖，允許多個線程同時訪問臨界資源，而一個QMutex只保護一個臨界資源。QSemaphore 類的所有成員函數(shù)是線程安全的。

    經(jīng)典的生產(chǎn)者-消費者模型如下：某工廠只有固定倉位，生產(chǎn)人員每天生產(chǎn)的產(chǎn)品數(shù)量不一，銷售人員每天銷售的產(chǎn)品數(shù)量也不一致。當(dāng)生產(chǎn)人員生產(chǎn)P個產(chǎn)品時，就一次需要P個倉位，當(dāng)銷售人員銷售C個產(chǎn)品時，就要求倉庫中有足夠多的產(chǎn)品才能銷售。如果剩余倉位沒有P個時，該批次的產(chǎn)品都不存入，當(dāng)當(dāng)前已有的產(chǎn)品沒有C個時，就不能銷售C個以上的產(chǎn)品，直到新產(chǎn)品加入后方可銷售。

    QSemaphore來控制對環(huán)狀緩沖的訪問，此緩沖區(qū)被生產(chǎn)者線程和消費者線程共享。生產(chǎn)者不斷向緩沖區(qū)寫入數(shù)據(jù)直到緩沖末端，再從頭開始。消費者從緩沖不斷讀取數(shù)據(jù)。信號量比互斥量有更好的并發(fā)性，假如我們用互斥量來控制對緩沖的訪問，那么生產(chǎn)者、消費者不能同時訪問緩沖區(qū)。然而，我們知道在同一時刻，不同線程訪問緩沖的不同部分并沒有什么危害。

QSemaphore 類成員函數(shù)：

QSemaphore ( int n = 0 )
void acquire ( int n = 1 )
int available () const
void release ( int n = 1 )
bool tryAcquire ( int n = 1 )
bool tryAcquire ( int n, int timeout )

實例代碼：

 QSemaphore sem(5);      // sem.available() == 5
 sem.acquire(3);         // sem.available() == 2
 sem.acquire(2);         // sem.available() == 0
 sem.release(5);         // sem.available() == 5
 sem.release(5);         // sem.available() == 10
 sem.tryAcquire(1);      // sem.available() == 9, returns true
 sem.tryAcquire(250);    // sem.available() == 9, returns false

生產(chǎn)者-消費者實例：

#include <QtCore/QCoreApplication>
#include <QSemaphore>
#include <cstdlib>
#include <cstdio>
const int DataSize = 100000;
const int BufferSize = 8192;
char buffer[BufferSize];
QSemaphore  production(BufferSize);
QSemaphore  consumption;
class Producor:public QThread
    void run();
void Producor::run()
    for(int i = 0; i < DataSize; i++)
        production.acquire();
        buffer[i%BufferSize] = "ACGT"[(int)qrand()%4];
        consumption.release();
}
class Consumer:public QThread
void Consumer::run()
        consumption.acquire();
        fprintf(stderr, "%c", buffer[i%BufferSize]);
        production.release();
    fprintf(stderr, "%c", "\n");
int main(int argc, char *argv[])
    QCoreApplication a(argc, argv);
    Producor productor;
    Consumer consumer;
    productor.start();
    consumer.start();
    productor.wait();
    consumer.wait();
    return a.exec();

Producer::run函數(shù)：
   當(dāng)producer線程執(zhí)行run函數(shù)，如果buffer中已滿，而consumer線程沒有讀，producer不能再往buffer中寫字符,在 productor.acquire 處阻塞直到 consumer線程讀(consume）數(shù)據(jù)。一旦producer獲取到一個字節(jié)(資源）就寫入一個隨機的字符，并調(diào)用 consumer.release 使consumer線程可以獲取一個資源(讀一個字節(jié)的數(shù)據(jù)）。

Consumer::run函數(shù)：
   當(dāng)consumer線程執(zhí)行run函數(shù)，如果buffer中沒有數(shù)據(jù)，則consumer線程在consumer.acquire處阻塞，直到producer線程執(zhí)行寫操作寫入一個字節(jié)，并執(zhí)行consumer.release 使consumer線程的可用資源數(shù)=1時，consumer線程從阻塞狀態(tài)中退出， 并將consumer 資源數(shù)-1，consumer當(dāng)前資源數(shù)=0。

7、等待條件QWaitCondition

    QWaitCondition 允許線程在某些情況發(fā)生時喚醒另外的線程。一個或多個線程可以阻塞等待QWaitCondition ,用wakeOne()或wakeAll()設(shè)置一個條件。wakeOne()隨機喚醒一個，wakeAll()喚醒所有。

QWaitCondition ()
bool wait ( QMutex * mutex, unsigned long time = ULONG_MAX )
bool wait ( QReadWriteLock * readWriteLock, unsigned long time = ULONG_MAX )
void wakeOne ()
void wakeAll ()

頭文件聲明：    #include <QWaitCondition>
等待條件聲明：    QWaitCondtion m_WaitCondition;
等待條件等待：    m_WaitConditon.wait(&m_muxtex, time);
等待條件喚醒：    m_WaitCondition.wakeAll();

在經(jīng)典的生產(chǎn)者-消費者場合中，生產(chǎn)者首先必須檢查緩沖是否已滿(numUsedBytes==BufferSize)，如果緩沖區(qū)已滿，線程停下來等待 bufferNotFull條件。如果沒有滿，在緩沖中生產(chǎn)數(shù)據(jù)，增加numUsedBytes,激活條件 bufferNotEmpty。使用mutex來保護對numUsedBytes的訪問。QWaitCondition::wait() 接收一個mutex作為參數(shù)，mutex被調(diào)用線程初始化為鎖定狀態(tài)。在線程進入休眠狀態(tài)之前，mutex會被解鎖。而當(dāng)線程被喚醒時，mutex會處于鎖定狀態(tài),從鎖定狀態(tài)到等待狀態(tài)的轉(zhuǎn)換是原子操作。當(dāng)程序開始運行時，只有生產(chǎn)者可以工作，消費者被阻塞等待bufferNotEmpty條件，一旦生產(chǎn)者在緩沖中放入一個字節(jié)，bufferNotEmpty條件被激發(fā)，消費者線程于是被喚醒。

#include <QWaitCondition>
#include <QMutex>
#include <QTime>
const int DataSize = 32;
const int BufferSize = 16;
QWaitCondition bufferNotEmpty;
QWaitCondition bufferNotFull;
int used = 0;
    qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
        mutex.lock();
        if(used == BufferSize)
            bufferNotFull.wait(&mutex);
        mutex.unlock();
        buffer[i%BufferSize] = used;
        used++;
        bufferNotEmpty.wakeAll();
        if(used == 0)
            bufferNotEmpty.wait(&mutex);
        fprintf(stderr, "%d\n", buffer[i%BufferSize]);
        used--;
        bufferNotFull.wakeAll();

8、高級事件隊列

QT事件系統(tǒng)對進程間通信很重要，每個進程可以有自己的事件循環(huán)，要在另外一個線程中調(diào)用一個槽函數(shù)（或任何invokable方法），需要將調(diào)用槽函數(shù)放置在目標(biāo)線程的事件循環(huán)中，讓目標(biāo)線程在槽函數(shù)開始運行之前，先完成自己的當(dāng)前任務(wù)，而原來的線程繼續(xù)并行運行。

要在一個事件循環(huán)中執(zhí)行調(diào)用槽函數(shù)，需要一個queued信號槽連接。每當(dāng)信號發(fā)出時，信號的參數(shù)將被事件系統(tǒng)記錄。信號接收者存活的線程將運行槽函數(shù)。另外，不使用信號，調(diào)用QMetaObject::invokeMethod()也可以達到相同的效果。在這兩種情況下，必須使用queued連接，因為direct連接繞過了事件系統(tǒng)，并且立即在當(dāng)前線程中運行此方法。

    當(dāng)線程同步使用事件系統(tǒng)時，沒有死鎖風(fēng)險。然而，事件系統(tǒng)不執(zhí)行互斥。如果調(diào)用方法訪問共享數(shù)據(jù)，仍然需要使用QMutex來保護。

如果只使用信號槽，并且線程間沒有共享變量，那么，多線程程序可以完全沒有低級原語。

五、可重入與線程安全

可重入reentrant與線程安全thread-safe被用來說明一個函數(shù)如何用于多線程程序。
一個線程安全的函數(shù)可以同時被多個線程調(diào)用，甚至調(diào)用者會使用共享數(shù)據(jù)也沒有問題，因為對共享數(shù)據(jù)的訪問是串行的。一個可重入函數(shù)也可以同時被多個線程調(diào)用，但是每個調(diào)用者只能使用自己的數(shù)據(jù)。因此，一個線程安全的函數(shù)總是可重入的，但一個可重入的函數(shù)并不一定是線程安全的。
    一個可重入的類，指的是類的成員函數(shù)可以被多個線程安全地調(diào)用，只要每個線程使用類的不同的對象。而一個線程安全的類，指的是類的成員函數(shù)能夠被多線程安全地調(diào)用，即使所有的線程都使用類的同一個實例。

1、可重入

    大多數(shù)C++類是可重入的，因為它們典型地僅僅引用成員數(shù)據(jù)。任何線程可以訪問可重入類實例的成員函數(shù)，只要同一時間沒有其他線程調(diào)用這個實例的成員函數(shù)。

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

    Counter類是可重入的，但卻不是線程安全的。假如多個線程都試圖修改數(shù)據(jù)成員n,結(jié)果未定義。
    大多數(shù)Qt類是可重入，非線程安全的。有一些類與函數(shù)是線程安全的，主要是線程相關(guān)的類，如QMutex,QCoreApplication::postEvent()。

2、線程安全

    所有的GUI類（如QWidget及其子類），操作系統(tǒng)核心類（如QProcess）和網(wǎng)絡(luò)類都不是線程安全的。

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

 Counter類是可重入和線程安全的。QMutexLocker類在構(gòu)造函數(shù)中自動對mutex進行加鎖，在析構(gòu)函數(shù)中進行解鎖。mutex使用了mutable關(guān)鍵字來修飾，因為在value()函數(shù)中對mutex進行加鎖與解鎖操作，而value()是一個const函數(shù)。

六、線程與信號槽

1、線程的依附性

    線程的依附性是對象與線程的關(guān)系。默認(rèn)情況下，對象依附于自身被創(chuàng)建的線程。
    對象的依附性與槽函數(shù)執(zhí)行的關(guān)系，默認(rèn)情況下，槽函數(shù)在其所依附的線程中被調(diào)用執(zhí)行。
    修改對象的依附性的方法：QObject::moveToThread函數(shù)用于改變對象的線程依附性，使得對象的槽函數(shù)在依附的線程中被調(diào)用執(zhí)行。

2、QObject與線程

QThread類具有發(fā)送信號和定義槽函數(shù)的能力。QThread主要信號如下：

• void started();線程開始運行時發(fā)送信號
• void finished();線程完成運行時發(fā)送信號
• void terminated();線程被異常終止時發(fā)送信號
  

    QThread繼承自QObject,發(fā)射信號以指示線程執(zhí)行開始與結(jié)束，并提供了許多槽函數(shù)。QObjects可以用于多線程，發(fā)射信號以在其它線程中調(diào)用槽函數(shù)，并且向“存活”于其它線程中的對象發(fā)送事件。

QObject的可重入性

    QObject是可重入的，QObject的大多數(shù)非GUI子類如 QTimer、QTcpSocket、QUdpSocket、QHttp、QFtp、QProcess也是可重入的，在多個線程中同時使用這些類是可能的。可重入的類被設(shè)計成在一個單線程中創(chuàng)建與使用，在一個線程中創(chuàng)建一個對象而在另一個線程中調(diào)用該對象的函數(shù)，不保證能行得通。有三種約束需要注意：

    A、一個QObject類型的孩子必須總是被創(chuàng)建在它的父親所被創(chuàng)建的線程中。這意味著，除了別的以外，永遠(yuǎn)不要把QThread對象（this）作為該線程中創(chuàng)建的一個對象的父親（因為QThread對象自身被創(chuàng)建在另外一個線程中）。
    B、事件驅(qū)動的對象可能只能被用在一個單線程中。特別適用于計時器機制（timer mechanism）和網(wǎng)絡(luò)模塊。例如：不能在不屬于這個對象的線程中啟動一個定時器或連接一個socket，必須保證在刪除QThread之前刪除所有創(chuàng)建在這個線程中的對象。在run()函數(shù)的實現(xiàn)中，通過在棧中創(chuàng)建這些對象，可以輕松地做到這一點。
    C、雖然QObject是可重入的，但GUI類，尤其是QWidget及其所有子類都不是可重入的，只能被用在GUI線程中。QCoreApplication::exec()必須也從GUI線程被調(diào)用。

    在實踐中，只能在主線程而非其它線程中使用GUI的類，可以很輕易地被解決：將耗時操作放在一個單獨的工作線程中，當(dāng)工作線程結(jié)束后在GUI線程中由屏幕顯示結(jié)果。

    一般來說，在QApplication前創(chuàng)建QObject是不行的，會導(dǎo)致奇怪的崩潰或退出，取決于平臺。因此，不支持QObject的靜態(tài)實例。一個單線程或多線程的應(yīng)用程序應(yīng)該先創(chuàng)建QApplication，并最后銷毀QObject。

3、線程的事件循環(huán)

    每個線程都有自己的事件循環(huán)。主線程通過QCoreApplication::exec()來啟動自己的事件循環(huán),但對話框的GUI應(yīng)用程序，有些時候用QDialog::exec()，其它線程可以用QThread::exec()來啟動事件循環(huán)。就像 QCoreApplication，QThread提供一個exit(int)函數(shù)和quit()槽函數(shù)。

    線程中的事件循環(huán)使得線程可以利用一些非GUI的、要求有事件循環(huán)存在的Qt類（例如：QTimer、QTcpSocket、和QProcess），使得連接一些線程的信號到一個特定線程的槽函數(shù)成為可能。

    一個QObject實例被稱為存活于它所被創(chuàng)建的線程中。關(guān)于這個對象的事件被分發(fā)到該線程的事件循環(huán)中?？梢杂肣Object::thread()方法獲取一個QObject所處的線程。

    QObject::moveToThread()函數(shù)改變一個對象和及其子對象的線程所屬性。（如果對象有父對象的話，對象不能被移動到其它線程中）。

從另一個線程（不是QObject對象所屬的線程）對該QObject對象調(diào)用delete方法是不安全的，除非能保證該對象在那個時刻不處理事件，使用QObejct::deleteLater()更好。一個DeferredDelete類型的事件將被提交（posted），而該對象的線程的 件循環(huán)最終會處理這個事件。默認(rèn)情況下，擁有一個QObject的線程就是創(chuàng)建QObject的線程，而不是 QObject::moveToThread()被調(diào)用后的。

    如果沒有事件循環(huán)運行，事件將不會傳遞給對象。例如：在一個線程中創(chuàng)建了一個QTimer對象，但從沒有調(diào)用exec()，那么，QTimer就永遠(yuǎn)不會發(fā)射timeout()信號，即使調(diào)用deleteLater()也不行。（這些限制也同樣適用于主線程）。

    利用線程安全的方法QCoreApplication::postEvent()，可以在任何時刻給任何線程中的任何對象發(fā)送事件，事件將自動被分發(fā)到該對象所被創(chuàng)建的線程事件循環(huán)中。

    所有的線程都支持事件過濾器，而限制是監(jiān)控對象必須和被監(jiān)控對象存在于相同的線程中。QCoreApplication::sendEvent()（不同于postEvent()）只能將事件分發(fā)到和該函數(shù)調(diào)用者相同的線程中的對象。

4、其他線程訪問QObject子類

    QObject及其所有子類都不是線程安全的。這包含了整個事件交付系統(tǒng)。重要的是，切記事件循環(huán)可能正在向你的QObject子類發(fā)送事件，當(dāng)你從另一個線程訪問該對象時。
    如果你正在調(diào)用一個QObject子類的函數(shù)，而該子類對象并不存活于當(dāng)前線程中，并且該對象是可以接收事件的，那么你必須用一個mutex保護對該QObject子類的內(nèi)部數(shù)據(jù)的所有訪問，否則，就有可能發(fā)生崩潰和非預(yù)期的行為。
    同其它對象一樣，QThread對象存活于該對象被創(chuàng)建的線程中 – 而并非是在QThread::run()被調(diào)用時所在的線程。一般來說，在QThread子類中提供槽函數(shù)是不安全的，除非用一個mutex保護成員變量。
    另一方面，可以在QThread::run()的實現(xiàn)中安全地發(fā)射信號，因為信號發(fā)射是線程安全的。

5、跨線程的信號槽

    線程的信號槽機制需要開啟線程的事件循環(huán)機制，即調(diào)用QThread::exec()函數(shù)開啟線程的事件循環(huán)。
Qt信號-槽連接函數(shù)原型如下：

bool QObject::connect ( const QObject * sender, const char * signal, const QObject * receiver, const char *method, Qt::ConnectionType type = Qt::AutoConnection ) 

Qt支持5種連接方式

A、Qt::DirectConnection（直連方式）（信號與槽函數(shù)關(guān)系類似于函數(shù)調(diào)用，同步執(zhí)行）
    當(dāng)信號發(fā)出后，相應(yīng)的槽函數(shù)將立即被調(diào)用。emit語句后的代碼將在所有槽函數(shù)執(zhí)行完畢后被執(zhí)行。
    當(dāng)信號發(fā)射時，槽函數(shù)將直接被調(diào)用。
    無論槽函數(shù)所屬對象在哪個線程，槽函數(shù)都在發(fā)射信號的線程內(nèi)執(zhí)行。
B、Qt::QueuedConnection（隊列方式）（此時信號被塞到事件隊列里，信號與槽函數(shù)關(guān)系類似于消息通信，異步執(zhí)行）
    當(dāng)信號發(fā)出后，排隊到信號隊列中，需等到接收對象所屬線程的事件循環(huán)取得控制權(quán)時才取得該信號，調(diào)用相應(yīng)的槽函數(shù)。emit語句后的代碼將在發(fā)出信號后立即被執(zhí)行，無需等待槽函數(shù)執(zhí)行完畢。
    當(dāng)控制權(quán)回到接收者所依附線程的事件循環(huán)時，槽函數(shù)被調(diào)用。
    槽函數(shù)在接收者所依附線程執(zhí)行。
C、Qt::AutoConnection（自動方式）
     Qt的默認(rèn)連接方式，如果信號的發(fā)出和接收信號的對象同屬一個線程，那個工作方式與直連方式相同；否則工作方式與隊列方式相同。
如果信號在接收者所依附的線程內(nèi)發(fā)射，則等同于直接連接
如果發(fā)射信號的線程和接受者所依附的線程不同，則等同于隊列連接
D、Qt::BlockingQueuedConnection(信號和槽必須在不同的線程中，否則就產(chǎn)生死鎖)
    槽函數(shù)的調(diào)用情形和Queued Connection相同，不同的是當(dāng)前的線程會阻塞住，直到槽函數(shù)返回。
E、Qt::UniqueConnection
    與默認(rèn)工作方式相同，只是不能重復(fù)連接相同的信號和槽，因為如果重復(fù)連接就會導(dǎo)致一個信號發(fā)出，對應(yīng)槽函數(shù)就會執(zhí)行多次。

    QThread是用來管理線程的，QThread對象所依附的線程和所管理的線程并不是同一個概念。QThread所依附的線程，就是創(chuàng)建QThread對象的線程，QThread 所管理的線程，就是run啟動的線程，也就是新建線程。QThread對象依附在主線程中，QThread對象的slot函數(shù)會在主線程中執(zhí)行，而不是次線程。除非QThread對象依附到次線程中(通過movetoThread)。
工程實踐中，為了避免凍結(jié)主線程的事件循環(huán)（即避免因此而凍結(jié)了應(yīng)用的UI），所有的計算工作是在一個單獨的工作線程中完成的，工作線程結(jié)束時發(fā)射一個信號，通過信號的參數(shù)將工作線程的狀態(tài)發(fā)送到GUI線程的槽函數(shù)中更新GUI組件狀態(tài)。

七、線程的設(shè)計

1、線程的生命周期

如果線程的正處于執(zhí)行過程中時，線程對象被銷毀時，程序?qū)鲥e。
工程實踐中線程對象的生命期必須大于線程的生命期。

2、同步線程類設(shè)計

線程對象主動等待線程生命期結(jié)束后才銷毀，線程對象銷毀時確保線程執(zhí)行結(jié)束，支持在?；蚨焉蟿?chuàng)建線程對象。
在線程類的析構(gòu)函數(shù)中先調(diào)用wait函數(shù)，強制等待線程執(zhí)行結(jié)束。
使用場合：適用于線程生命期較短的場合

#ifndef SYNCTHREAD_H
#define SYNCTHREAD_H
class SyncThread : public QThread
  Q_OBJECT
  explicit SyncThread(QObject* parent = 0):QThread(parent)
  ~SyncThread()
    wait();
#endif // SYNCTHREAD_H

3、異步線程類設(shè)計

線程生命期結(jié)束時通知線程對象銷毀。
只能在堆空間創(chuàng)建線程對象，線程對象不能被外界主動銷毀。
在run函數(shù)中最后調(diào)用deleteLater()函數(shù)。
線程函數(shù)主動申請銷毀線程對象。
使用場合：
線程生命期不可控，需要長時間運行于后臺的線程。

#ifndef ASYNCTHREAD_H
#define ASYNCTHREAD_H
class AsyncThread : public QThread
    deleteLater();
  explicit AsyncThread(QObject* parent = 0):QThread(parent)
  ~AsyncThread()
  static AsyncThread* newThread(QObject* parent = 0)
    return new AsyncThread(parent);
#endif // ASYNCTHREAD_H

八、線程的使用方式

1、子類化QThread

QThread的兩種使用方法:
（1）不使用事件循環(huán)
 A、子類化 QThread
    B、重寫run函數(shù)，run函數(shù)內(nèi)有一個 while 或 for 的死循環(huán)
    C、設(shè)置一個標(biāo)記為來控制死循環(huán)的退出。
    適用于后臺執(zhí)行長時間的耗時操作，如文件復(fù)制、網(wǎng)絡(luò)數(shù)據(jù)讀取。
（2）使用事件循環(huán)。
    A、子類化 QThread
    B、重寫run 使其調(diào)用 QThread::exec() ，開啟線程的事件循環(huán)
C、為子類定義信號和槽，由于槽函數(shù)并不會在新開的 Thread 運行，在構(gòu)造函數(shù)中調(diào)用 moveToThread(this)。
適用于事務(wù)性操作，如文件讀寫、數(shù)據(jù)庫讀寫。

2、Worker-Object

    在Qt4.4之前，run 是純虛函數(shù)，必須子類化QThread來實現(xiàn)run函數(shù)。
    而從Qt4.4開始，QThread不再支持抽象類，run 默認(rèn)調(diào)用 QThread::exec() ，不需要子類化 QThread，只需要子類化一個 QObject 。
    通過繼承的方式實現(xiàn)多線程已經(jīng)沒有任何意義，QThread是操作系統(tǒng)線程的接口或控制點，用于充當(dāng)線程操作的集合。
    使用Worker-Object通過QObject::moveToThread將它們移動到線程中。
    指定一個線程對象的線程入口函數(shù)的方法：
A、在類中定義一個槽函數(shù)void tmain()作為線程入口函數(shù)
B、在類中定義一個QThread成員對象m_thread
C、改變當(dāng)前對象的線程依附性到m_thread
D、連接m_thread的started()信號到tmain槽函數(shù)。

#ifndef WORKER_H
#define WORKER_H
#include <QObject>
class Worker : public QObject
  QThread m_thread;
protected slots:
  void tmain()
    qDebug() << "void tmain()";
  explicit Worker(QObject* parent = 0):QObject(parent)
    moveToThread(&m_thread);
    connect(&m_thread, SIGNAL(started()), this, SLOT(tmain()));
  void start()
    m_thread.start();
  void terminate()
    m_thread.terminate();
  void exit(int c)
    m_thread.exit(c);
  ~Worker()
    m_thread.wait();
#endif // WORKER_H

九、多線程與GUI組件的通信

1、多線程與GUI組件通信基礎(chǔ)

    GUI系統(tǒng)的設(shè)計原則：
    所有界面組件的創(chuàng)建只能在GUI線程（主線程）中完成。子線程與界面組件的通信有兩種方式：
    A、信號槽方式
    B、發(fā)送自定事件方式

2、信號槽方式

使用信號槽解決多線程與界面組件的通信的方案：
A、在子線程中定義界面組件的更新信號
B、在主窗口類中定義更新界面組件的槽函數(shù)
C、使用異步方式連接更新信號到槽函數(shù)
子線程通過發(fā)送信號的方式更新界面組件，所有的界面組件對象只能依附于GUI線程（主線程）。
子線程更新界面狀態(tài)的本質(zhì)是子線程發(fā)送信號通知主線程界面更新請求，主線程根據(jù)具體信號以及信號參數(shù)對界面組件進行修改。
使用信號槽在子線程中更新主界面中進度條的進度顯示信息。
工作線程類：

signals:
  void signalProgressValue(int value);
    work();
    exec();
    moveToThread(this);
  void work()
    for(int i = 0; i < 11; i++)
        emit signalProgressValue(i*10);
        sleep(1);

主界面類：

#ifndef WIDGET_H
#define WIDGET_H
#include <QWidget>
#include <QProgressBar>
#include "WorkThread.h"
class Widget : public QWidget
  QProgressBar* m_progress;//進度條
  WorkThread* m_thread;//工作線程
  Widget(QWidget *parent = 0):QWidget(parent)
    m_progress = new QProgressBar(this);
    m_progress->move(10, 10);
    m_progress->setMinimum(0);
    m_progress->setMaximum(100);
    m_progress->setTextVisible(true);
    m_progress->resize(100, 30);
    m_thread = new WorkThread();
    m_thread->start();
    connect(m_thread, SIGNAL(finished()), m_thread, SLOT(deleteLater()));
    //連接工作線程的信號到界面的槽函數(shù)
    connect(m_thread, SIGNAL(signalProgressValue(int)), this, SLOT(onProgress(int)));
  ~Widget()
  void onProgress(int value)
    m_progress->setValue(value);
#endif // WIDGET_H

Main函數(shù)：

#include "Widget.h"
#include <QApplication>
  QApplication a(argc, argv);
  Widget w;
  w.show();
  return a.exec();

3、發(fā)送自定義事件方式

    A、自定義事件用于描述界面更新細(xì)節(jié)
    B、在主窗口類中重寫事件處理函數(shù)event
    C、使用postEvent函數(shù)（異步方式）發(fā)送自定義事件類對象
    子線程指定接收消息的對象為主窗口對象，在event事件處理函數(shù)更新界面狀態(tài)
    事件對象在主線程中被處理，event函數(shù)在主線程中調(diào)用。
    發(fā)送的事件對象必須在堆空間創(chuàng)建
    子線程創(chuàng)建時必須附帶目標(biāo)對象的地址信息
自定義事件類：

#ifndef PROGRESSEVENT_H
#define PROGRESSEVENT_H
#include <QEvent>
class ProgressEvent : public QEvent
  int m_progress;
  const static Type TYPE = static_cast<Type>(QEvent::User + 0xFF);
  ProgressEvent(int progress = 0):QEvent(TYPE)
    m_progress = progress;
  int progress()const
    return m_progress;
#endif // PROGRESSEVENT_H

自定義線程類：

#include <ProgressEvent.h>
        QApplication::postEvent(parent(), new ProgressEvent(i*10));

自定義界面類：

#ifndef WIDGETUI_H
#define WIDGETUI_H
#include "ProgressEvent.h"
class WidgetUI : public QWidget
  WidgetUI(QWidget *parent = 0):QWidget(parent)
    m_thread->setParent(this);
  ~WidgetUI()
    m_thread->quit();
  bool event(QEvent *event)
    bool ret = true;
    if(event->type() == ProgressEvent::TYPE)
        ProgressEvent* evt = dynamic_cast<ProgressEvent*>(event);
        if(evt != NULL)
            //設(shè)置進度條的進度為事件參數(shù)的值
            m_progress->setValue(evt->progress());
    else
        ret = QWidget::event(event);
    return ret;
#endif // WIDGETUI_H
#include "WidgetUI.h"
  WidgetUI w;

到此這篇關(guān)于深入理解QT多線程編程 的文章就介紹到這了,更多相關(guān)QT多線程編程 內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論