一、線程基礎(chǔ)

1、GUI線程與工作線程

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

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

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

二、QT多線程簡(jiǎn)介

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

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

三、QThread線程

1、QThread線程基礎(chǔ)

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

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

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

    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ùn)行線程的優(yōu)先級(jí)。如果線程沒(méi)有運(yùn)行，此函數(shù)不執(zhí)行任何操作并立即返回。使用的start()來(lái)啟動(dòng)一個(gè)線程具有特定的優(yōu)先級(jí)。優(yōu)先級(jí)參數(shù)可以是QThread::Priority枚舉除InheritPriortyd的任何值。

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

 void start ( Priority priority = InheritPriority )

啟動(dòng)線程執(zhí)行，啟動(dòng)后會(huì)發(fā)出started ()信號(hào)

4、線程的執(zhí)行

int exec() [protected] 

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

void run() [virtual protected] 

線程的起點(diǎn)，在調(diào)用start()之后，新創(chuàng)建的線程就會(huì)調(diào)用run函數(shù)，默認(rèn)實(shí)現(xiàn)調(diào)用exec()，大多數(shù)需要重新實(shí)現(xiàn)run函數(shù)，便于管理自己的線程。run函數(shù)返回時(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)。

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

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

void requestInterruption() 

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

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

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

#ifndef WORKTHREAD_H
#define WORKTHREAD_H
#include <QThread>
#include <QDebug>
class WorkThread : public QThread
{
protected:
  //線程退出的標(biāo)識(shí)量
  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 )

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

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

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

一般情況下，wait()和sleep()函數(shù)應(yīng)該不需要，因?yàn)镼t是一個(gè)事件驅(qū)動(dòng)型框架。考慮監(jiān)聽finished()信號(hào)來(lái)取代wait()，使用QTimer來(lái)取代sleep()。

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

bool isFinished () const  線程是否已經(jīng)退出
bool isRunning () const   線程是否處于運(yùn)行狀態(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)實(shí)現(xiàn)調(diào)用了exec()，從而創(chuàng)建一個(gè)QEventLoop對(duì)象，由QEventLoop對(duì)象處理線程中事件隊(duì)列（每一個(gè)線程都有一個(gè)屬于自己的事件隊(duì)列）中的事件。exec()在其內(nèi)部不斷做著循環(huán)遍歷事件隊(duì)列的工作，調(diào)用QThread的quit()或exit()方法使退出線程，盡量不要使用terminate()退出線程，terminate()退出線程過(guò)于粗暴，造成資源不能釋放，甚至互斥鎖還處于加鎖狀態(tài)。

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

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

四、線程的同步

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

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

2、互斥量QMutex

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

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

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

QMutex ( RecursionMode mode = NonRecursive )

QMutex有兩種模式：Recursive, NonRecursive

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

B、NonRecursive
    默認(rèn)模式，mutex只能被lock一次。
    如果使用了Mutex.lock()而沒(méi)有對(duì)應(yīng)的使用Mutex.unlcok()的話就會(huì)造成死鎖，其他的線程將永遠(yuǎn)也得不到接觸Mutex鎖住的共享資源的機(jī)會(huì)。盡管可以不使用lock()而使用tryLock(timeout)來(lái)避免因?yàn)樗赖榷斐傻乃梨i( tryLock(負(fù)值)==lock()),但是還是很有可能造成錯(cuò)誤。

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

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

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

4、QReadWriteLock

    QReadWriterLock 與QMutex相似，但對(duì)讀寫操作訪問(wèn)進(jìn)行區(qū)別對(duì)待，可以允許多個(gè)讀者同時(shí)讀數(shù)據(jù)，但只能有一個(gè)寫，并且寫讀操作不同同時(shí)進(jìn)行。使用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 ()
使用實(shí)例：
QReadWriteLock lock;
 void ReaderThread::run()
     lock.lockForRead();
     read_file();
     lock.unlock();
 void WriterThread::run()
     lock.lockForWrite();
     write_file();

5、QReadLocker和QWriteLocker

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

 QByteArray readData()
     ...
     return data;

使用QReadLocker：

 QReadLocker locker(&lock);

6、信號(hào)量QSemaphore

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

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

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

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 )

實(shí)例代碼：

 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)者-消費(fèi)者實(shí)例：

#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線程沒(méi)有讀，producer不能再往buffer中寫字符,在 productor.acquire 處阻塞直到 consumer線程讀(consume）數(shù)據(jù)。一旦producer獲取到一個(gè)字節(jié)(資源）就寫入一個(gè)隨機(jī)的字符，并調(diào)用 consumer.release 使consumer線程可以獲取一個(gè)資源(讀一個(gè)字節(jié)的數(shù)據(jù)）。

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

7、等待條件QWaitCondition

    QWaitCondition 允許線程在某些情況發(fā)生時(shí)喚醒另外的線程。一個(gè)或多個(gè)線程可以阻塞等待QWaitCondition ,用wakeOne()或wakeAll()設(shè)置一個(gè)條件。wakeOne()隨機(jī)喚醒一個(gè)，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)者-消費(fèi)者場(chǎng)合中，生產(chǎn)者首先必須檢查緩沖是否已滿(numUsedBytes==BufferSize)，如果緩沖區(qū)已滿，線程停下來(lái)等待 bufferNotFull條件。如果沒(méi)有滿，在緩沖中生產(chǎn)數(shù)據(jù)，增加numUsedBytes,激活條件 bufferNotEmpty。使用mutex來(lái)保護(hù)對(duì)numUsedBytes的訪問(wèn)。QWaitCondition::wait() 接收一個(gè)mutex作為參數(shù)，mutex被調(diào)用線程初始化為鎖定狀態(tài)。在線程進(jìn)入休眠狀態(tài)之前，mutex會(huì)被解鎖。而當(dāng)線程被喚醒時(shí)，mutex會(huì)處于鎖定狀態(tài),從鎖定狀態(tài)到等待狀態(tài)的轉(zhuǎn)換是原子操作。當(dāng)程序開始運(yùn)行時(shí)，只有生產(chǎn)者可以工作，消費(fèi)者被阻塞等待bufferNotEmpty條件，一旦生產(chǎn)者在緩沖中放入一個(gè)字節(jié)，bufferNotEmpty條件被激發(fā)，消費(fèi)者線程于是被喚醒。

#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、高級(jí)事件隊(duì)列

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

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

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

如果只使用信號(hào)槽，并且線程間沒(méi)有共享變量，那么，多線程程序可以完全沒(méi)有低級(jí)原語(yǔ)。

五、可重入與線程安全

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

1、可重入

    大多數(shù)C++類是可重入的，因?yàn)樗鼈兊湫偷貎H僅引用成員數(shù)據(jù)。任何線程可以訪問(wèn)可重入類實(shí)例的成員函數(shù)，只要同一時(shí)間沒(méi)有其他線程調(diào)用這個(gè)實(shí)例的成員函數(shù)。

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

    Counter類是可重入的，但卻不是線程安全的。假如多個(gè)線程都試圖修改數(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ù)中自動(dòng)對(duì)mutex進(jìn)行加鎖，在析構(gòu)函數(shù)中進(jìn)行解鎖。mutex使用了mutable關(guān)鍵字來(lái)修飾，因?yàn)樵趘alue()函數(shù)中對(duì)mutex進(jìn)行加鎖與解鎖操作，而value()是一個(gè)const函數(shù)。

六、線程與信號(hào)槽

1、線程的依附性

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

2、QObject與線程

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

• void started();線程開始運(yùn)行時(shí)發(fā)送信號(hào)
• void finished();線程完成運(yùn)行時(shí)發(fā)送信號(hào)
• void terminated();線程被異常終止時(shí)發(fā)送信號(hào)
  

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

QObject的可重入性

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

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

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

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

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

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

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

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

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

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

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

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

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

4、其他線程訪問(wèn)QObject子類

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

5、跨線程的信號(hào)槽

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

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

七、線程的設(shè)計(jì)

1、線程的生命周期

如果線程的正處于執(zhí)行過(guò)程中時(shí)，線程對(duì)象被銷毀時(shí)，程序?qū)?huì)出錯(cuò)。
工程實(shí)踐中線程對(duì)象的生命期必須大于線程的生命期。

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

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

#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è)計(jì)

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

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

2、Worker-Object

    在Qt4.4之前，run 是純虛函數(shù)，必須子類化QThread來(lái)實(shí)現(xiàn)run函數(shù)。
    而從Qt4.4開始，QThread不再支持抽象類，run 默認(rèn)調(diào)用 QThread::exec() ，不需要子類化 QThread，只需要子類化一個(gè) QObject 。
    通過(guò)繼承的方式實(shí)現(xiàn)多線程已經(jīng)沒(méi)有任何意義，QThread是操作系統(tǒng)線程的接口或控制點(diǎn)，用于充當(dāng)線程操作的集合。
    使用Worker-Object通過(guò)QObject::moveToThread將它們移動(dòng)到線程中。
    指定一個(gè)線程對(duì)象的線程入口函數(shù)的方法：
A、在類中定義一個(gè)槽函數(shù)void tmain()作為線程入口函數(shù)
B、在類中定義一個(gè)QThread成員對(duì)象m_thread
C、改變當(dāng)前對(duì)象的線程依附性到m_thread
D、連接m_thread的started()信號(hào)到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è)計(jì)原則：
    所有界面組件的創(chuàng)建只能在GUI線程（主線程）中完成。子線程與界面組件的通信有兩種方式：
    A、信號(hào)槽方式
    B、發(fā)送自定事件方式

2、信號(hào)槽方式

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

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;//進(jìn)度條
  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()));
    //連接工作線程的信號(hào)到界面的槽函數(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ā)送自定義事件類對(duì)象
    子線程指定接收消息的對(duì)象為主窗口對(duì)象，在event事件處理函數(shù)更新界面狀態(tài)
    事件對(duì)象在主線程中被處理，event函數(shù)在主線程中調(diào)用。
    發(fā)送的事件對(duì)象必須在堆空間創(chuàng)建
    子線程創(chuàng)建時(shí)必須附帶目標(biāo)對(duì)象的地址信息
自定義事件類：

#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è)置進(jìn)度條的進(jìn)度為事件參數(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)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評(píng)論