Qt多線程和GUI界面假死

QThread的常見特性：

　　run()是線程的入口，就像main()對於應用程序的做用。QThread中對run()的默認實現調用了exec()，從而建立一個QEventLoop對象，由其處理該線程事件隊列（每個線程都有一個屬於本身的事件隊列）中的事件。簡單用代碼描述以下：

 1 int QThread::exec()  
 2 {  
 3 //...  
 4     QEventLoop eventLoop;  
 5     int returnCode = eventLoop.exec();  
 6 //...  
 7     return returnCode;  
 8 }  
 9    
10 int QEventLoop::exec(ProcessEventsFlags flags)  
11 {  
12 //...  
13     while (!d->exit) {  
14         while (!posted_event_queue_is_empty) {  
15             process_next_posted_event();  
16         }  
17     }  
18 //...  
19 }  

　　因而可知，exec()在其內部不斷作着循環遍歷事件隊列的工做，調用QThread的quit()或exit()方法使中止工做，儘可能不要使用terminate()，該方法過於粗暴，形成資源不能釋放，甚至互斥鎖還處於加鎖狀態。

 

1.舊的使用方式：

 1 #include "QThread"  
 2 #include "QMutexLocker"  
 3 #include "QMutex"  
 4 class Thread:public QThread  
 5 {  
 6     Q_OBJECT  
 7 public:  
 8     Thread();  
 9     void stop();  
10 private:  
11     bool m_stopFlag;  
12     QMutex mutex;  
13 protected:  
14     void run();  
15 };  
16 Thread::Thread()  
17 {  
18     m_stopFlag = false;  
19 }  
20    
21 void Thread::stop()  
22 {  
23     QMutexLocker locker(&mutex);  
24     m_stopFlag = true;  
25 }  
26    
27 void Thread::run()  
28 {  
29     while(1){  
30         {  
31             QMutexLocker locker(&mutex);  
32             if(m_stopFlag)  
33                 break;  
34         }  
35         qDebug()<<"This is in thread["<<currentThreadId()<<"]."<<(int)currentThread();  
36         sleep(2);  
37     }  
38     m_stopFlag = false;  
39 }  

 

 1 int main(int argc, char *argv[])  
 2 {  
 3     QCoreApplication a(argc, argv);  
 4     qDebug()<<"From main thread: "<<QThread::currentThreadId();  
 5    
 6     Thread t;  
 7     QObject::connect(&t, SIGNAL(finished()), &a, SLOT(quit()));  
 8     t.start();  
 9     return a.exec();  
10 }  

 

 1 int main(int argc, char *argv[])  
 2 {  
 3     QCoreApplication a(argc, argv);  
 4     qDebug()<<"From main thread: "<<QThread::currentThreadId();  
 5    
 6     Thread t;  
 7     QObject::connect(&t, SIGNAL(finished()), &a, SLOT(quit()));  
 8     t.start();  
 9     return a.exec();  
10 }  

 

　　這是qt4.6及以前的使用方法，這種方式本沒有什麼錯誤，能夠處理咱們的絕大多數需求。Thread對象自己工做在主線程下，即便調用的t.stop()方法，它也是工做在主線程下，只有run()範圍內的代碼工做在次線程中。

 

 1 class WorkerThread : public QThread  
 2 {  
 3     Q_OBJECT  
 4   
 5     void run() Q_DECL_OVERRIDE {  
 6         QString result;  
 7         emit resultReady(result);  
 8     }  
 9   
10 signals:  
11     void resultReady(const QString &s);  
12 };  
13   
14 void MyObject::startWorkInAThread()  
15 {  
16     WorkerThread *workerThread = new WorkerThread(this);  
17     connect(workerThread, &WorkerThread::resultReady, this, &MyObject::handleResults);  
18     connect(workerThread, &WorkerThread::finished, workerThread, &QObject::deleteLater);  
19     workerThread->start();  
20 } 

 

　　從Qt4.8起，能夠釋放運行剛剛結束的線程對象，經過鏈接finished()信號到QObject::deleteLater()。

 

2.推薦的使用方式：

 1 #include <QtCore>  
 2 class Worker : public QObject  
 3 {  
 4     Q_OBJECT  
 5 private slots:  
 6     void onTimeout()  
 7     {  
 8         qDebug()<<"Worker::onTimeout get called from?: "<<QThread::currentThreadId();  
 9     }  
10 };  

 

 1 #include "main.moc"  
 2 int main(int argc, char *argv[])  
 3 {  
 4     QCoreApplication a(argc, argv);  
 5     qDebug()<<"From main thread: "<<QThread::currentThreadId();  
 6    
 7     QThread t;  
 8     QTimer timer;  
 9     Worker worker;  
10    
11     QObject::connect(&timer, SIGNAL(timeout()), &worker, SLOT(onTimeout()));  
12     timer.start(1000);  
13    
14     worker.moveToThread(&t);  
15    
16     t.start();  
17    
18     return a.exec();  
19 }  

　　這是Qt4.7及之後版本推薦的工做方式。其主要特色就是利用Qt的事件驅動特性，將須要在次線程中處理的業務放在獨立的模塊（類）中，由主線程建立完該對象後，將其移交給指定的線程，且能夠將多個相似的對象移交給同一個線程。在這個例子中，信號由主線程的QTimer對象發出，以後Qt會將關聯的事件放到worker所屬線程的事件隊列。因爲隊列鏈接的做用，在不一樣線程間鏈接信號和槽是很安全的。
說說connect最後一個參數，鏈接類型：
1)自動鏈接(AutoConnection)，默認的鏈接方式，若是信號與槽，也就是發送者與接受者在同一線程，等同於直接鏈接；若是發送者與接受者處在不一樣線程，等同於隊列鏈接。
2)直接鏈接(DirectConnection)，當信號發射時，槽函數當即直接調用。不管槽函數所屬對象在哪一個線程，槽函數總在發送者所在線程執行。

3)隊列鏈接(QueuedConnection)，當控制權回到接受者所在線程的事件循環時，槽函數被調用。槽函數在接受者所在線程執行。

 

 1 class Worker : public QObject  
 2 {  
 3     Q_OBJECT  
 4   
 5 public slots:  
 6     void doWork(const QString meter) {  
 7         // ...  
 8         emit resultReady(result);  
 9     }  
10     void stopWork(){  
11         //...  
12     }  
13 signals:  
14     void resultReady(const QString &result);  
15 };  
16   
17 class Controller : public QObject  
18 {  
19     Q_OBJECT  
20   
21     QThread workerThread;  
22   
23 public:  
24     Controller() {  
25         Worker *worker = new Worker;  
26         worker->moveToThread(&workerThread);  
27         connect(workerThread, &QThread::finished, worker, &QObject::deleteLater);  
28         connect(this, &Controller::operate, worker, &Worker::doWork);  
29         connect(this, &Controller::kill, worker, &Worker::stopWork);  
30         connect(worker, &Worker::resultReady, this, &Controller::handleResults);  
31         workerThread.start();  
32     }  
33     ~Controller() {  
34         workerThread.quit();  
35         workerThread.wait();  
36     }  
37   
38 public slots:  
39     void handleResults(const QString &);  
40   
41 signals:  
42     void operate(const QString &);  
43     void kill();  
44 };  

 

 

　　使用新方式，子線程中的槽都在子線程中運行，主線程中的槽都在主線程中運行，信號和槽默認使用自動鏈接(AutoConnection)。值得注意的是，若是槽doWork中有耗時操做，好比說while循環，主線程的信號kill子線程是不會響應的，除非使用直接鏈接(DirectConnection)，connect(this, &Controller::kill, worker, &Worker::stopWork, Qt::DirectConnection);，此時，槽stopWork工做於主線程。

3.GUI界面假死的處理
　　在GUI程序中，主線程也叫GUI線程，由於它是惟一被容許執行GUI相關操做的線程。對於一些耗時的操做，若是放在主線程中，就是出現界面沒法響應的問題。這種問題的解決一種方式是，把這些耗時操做放到次線程中，還有一種比較簡單的方法：在處理耗時操做中頻繁調用QApplication::processEvents()。這個函數告訴Qt去處理那些尚未被處理的各種事件，而後再把控制權返還給調用者。

1 QElapsedTimer et;  
2 et.start();  
3 while(et.elapsed()<300)  
4     QCoreApplication::processEvents();

 

 

http://blog.csdn.net/emdfans/article/details/53896903