Qt优雅地结束线程（两种方法都是用Mutex锁住bool变量进行修改，然后由bool变量控制耗时动作的退出，即正常退出）

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

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

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

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

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

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

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. bool QThread::isInterruptionRequested() const
14. {
15. Q_D(const QThread);
16. QMutexLocker locker(&d->mutex);
17. if (!d->running || d->finished || d->isInFinish)
18. return false;
19. return d->interruptionRequested;
20. }

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

原文链接：http://blog.csdn.net/liang19890820/article/details/52186626

http://blog.csdn.net/caoshangpa/article/details/62421334