Qt 中线程的使用及中线程，以及常见问题

QThread的常见特性：

run()是线程的入口，就像main()对于应用程序的作用。QThread中对run()的默认实现调用了exec()，从而创建一个QEventLoop对象，由其处理该线程事件队列（每一个线程都有一个属于自己的事件队列）中的事件。简单用代码描述如下：

[cpp]  view plain  copy

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.旧的使用方式：

[cpp]  view plain  copy

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

[cpp]  view plain  copy

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()范围内的代码工作在次线程中。

[cpp]  view plain  copy

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.推荐的使用方式：

[cpp]  view plain  copy

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

[cpp]  view plain  copy

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)，当控制权回到接受者所在线程的事件循环时，槽函数被调用。槽函数在接受者所在线程执行。

[cpp]  view plain  copy

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

如果看不懂还可以看下面的例子：

使用方式:

解释：pTh实际上是新的线程，自己建的类通过moveToThread 绑定到新的线程中，通过connect连接将开始信号绑定到自己定义的函数当中。通过pTh->start()来开启线程。.quit 和.exit来关闭线程，当线程中有循环没结束时，是不能够正常退出的，可以通过isRunning() 和isFinished()来查看是否退出和线程的状态。

.如果一个线程运行完成，就会结束。可很多情况并非这么简单，由于某种特殊原因，当线程还未执行完时，我们就想中止它。
不恰当的中止往往会引起一些未知错误。比如：当关闭主界面的时候，很有可能次线程正在运行，这时，就会出现如下提示：
QThread: Destroyed while thread is still running
这是因为次线程还在运行，就结束了UI主线程，导致事件循环结束。这个问题在使用线程的过程中经常遇到，尤其是耗时操作。
在此问题上，常见的两种人：
1.直接忽略此问题。
2.强制中止 - terminate()。
大多数情况下，当程序退出时，次线程也许会正常退出。这时，虽然抱着侥幸心理，但隐患依然存在，也许在极少数情况下，就会出现Crash。
正如前面提到过terminate()，比较危险，不鼓励使用。线程可以在代码执行的任何点被终止。线程可能在更新数据时被终止，从而没有机会来清理自己，解锁等等。。。总之，只有在绝对必要时使用此函数。
所以，我们应该采取合理的措施来优雅地结束线程，一般思路：
1.发起线程退出操作，调用quit()或exit()。
2.等待线程完全停止，删除创建在堆上的对象。

3.适当的使用wait()（用于等待线程的退出）和合理的算法。

有循环要退出线程时就需要通过下面几种方法（需要自己去尝试那种适合你）

1.使用新方式，子线程中的槽都在子线程中运行，主线程中的槽都在主线程中运行，信号和槽默认使用自动连接(AutoConnection)。值得注意的是，如果槽doWork中有耗时操作，比如说while循环，主线程的信号kill子线程是不会响应的，除非使用直接连接(DirectConnection)，connect(this, &Controller::kill, worker, &Worker::stopWork, Qt::DirectConnection);，此时，槽stopWork工作于主线程。

2.QMutex互斥锁 + bool成员变量。
这种方式是Qt4.x中比较常用的，主要是利用“QMutex互斥锁 + bool成员变量”的方式来保证共享数据的安全性（可以完全参照下面的requestInterruption()源码写法）。

[cpp]  view plain  copy

1. #include <QThread>  
2. #include <QMutexLocker>  
3.   
4. class WorkerThread : public QThread  
5. {  
6.     Q_OBJECT  
7.   
8. public:  
9.     explicit WorkerThread(QObject *parent = 0)  
10.         : QThread(parent),  
11.           m_bStopped(false)  
12.     {  
13.         qDebug() << "Worker Thread : " << QThread::currentThreadId();  
14.     }  
15.   
16.     ~WorkerThread()  
17.     {  
18.         stop();  
19.         quit();  
20.         wait();  
21.     }  
22.   
23.     void stop()  
24.     {  
25.         qDebug() << "Worker Stop Thread : " << QThread::currentThreadId();  
26.         QMutexLocker locker(&m_mutex);  
27.         m_bStopped = true;  
28.     }  
29.   
30. protected:  
31.     virtual void run() Q_DECL_OVERRIDE {  
32.         qDebug() << "Worker Run Thread : " << QThread::currentThreadId();  
33.         int nValue = 0;  
34.         while (nValue < 100)  
35.         {  
36.             // 休眠50毫秒  
37.             msleep(50);  
38.             ++nValue;  
39.   
40.             // 准备更新  
41.             emit resultReady(nValue);  
42.   
43.             // 检测是否停止  
44.             {  
45.                 QMutexLocker locker(&m_mutex);  
46.                 if (m_bStopped)  
47.                     break;  
48.             }  
49.             // locker超出范围并释放互斥锁  
50.         }  
51.     }  
52. signals:  
53.     void resultReady(int value);  
54.   
55. private:  
56.     bool m_bStopped;  
57.     QMutex m_mutex;  
58. };  

为什么要加锁？很简单，是为了共享数据段操作的互斥。
何时需要加锁？在形成资源竞争的时候，也就是说，多个线程有可能访问同一共享资源的时候。
当主线程调用stop()更新m_bStopped的时候，run()函数也极有可能正在访问它（这时，他们处于不同的线程），所以存在资源竞争，因此需要加锁，保证共享数据的安全性。

3.Qt5以后：requestInterruption() + isInterruptionRequested()
这两个接口是Qt5.x引入的，使用很方便：

[cpp]  view plain  copy

1. class WorkerThread : public QThread  
2. {  
3.     Q_OBJECT  
4.   
5. public:  
6.     explicit WorkerThread(QObject *parent = 0)  
7.         : QThread(parent)  
8.     {  
9.     }  
10.   
11.     ~WorkerThread() {  
12.         // 请求终止  
13.         requestInterruption();  
14.         quit();  
15.         wait();  
16.     }  
17.   
18. protected:  
19.     virtual void run() Q_DECL_OVERRIDE {  
20.         // 是否请求终止  
21.         while (!isInterruptionRequested())  
22.         {  
23.             // 耗时操作  
24.         }  
25.     }  
26. };  

在耗时操作中使用isInterruptionRequested()来判断是否请求终止线程，如果没有，则一直运行；当希望终止线程的时候，调用requestInterruption()即可。
正如侯捷所言：「源码面前，了无秘密」。如果还心存疑虑，我们不妨来看看requestInterruption()、isInterruptionRequested()的源码：

[cpp]  view plain  copy

1. void QThread::requestInterruption()  
2. {  
3.     Q_D(QThread);  
4.     QMutexLocker locker(&d->mutex);  
5.     if (!d->running || d->finished || d->isInFinish)  
6.         return;  
7.     if (this == QCoreApplicationPrivate::theMainThread) {  
8.         qWarning("QThread::requestInterruption has no effect on the main thread");  
9.         return;  
10.     }  
11.     d->interruptionRequested = true;  
12. }  
13.   
14. bool QThread::isInterruptionRequested() const  
15. {  
16.     Q_D(const QThread);  
17.     QMutexLocker locker(&d->mutex);  
18.     if (!d->running || d->finished || d->isInFinish)  
19.         return false;  
20.     return d->interruptionRequested;  
21. }  

^_^，内部实现居然也用了互斥锁QMutex，这样我们就可以放心地使用了。

4.设置一个bool类型私有变量，放在循环前面，然后定义一个public函数，函数去改变bool类型的值，就可以跳出循环。

3.GUI界面假死的处理
在GUI程序中，主线程也叫GUI线程，因为它是唯一被允许执行GUI相关操作的线程。对于一些耗时的操作，如果放在主线程中，就是出现界面无法响应的问题。这种问题的解决一种方式是，把这些耗时操作放到次线程中，还有一种比较简单的方法：在处理耗时操作中频繁调用QApplication::processEvents()。这个函数告诉Qt去处理那些还没有被处理的各类事件，然后再把控制权返还给调用者。

[cpp]  view plain  copy

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

参考链接：https://blog.csdn.net/caoshangpa/article/details/52784860

参考链接：https://blog.csdn.net/caoshangpa/article/details/62421334