1、线程开启

Qt中，开启子线程，一般有两种方法：

a, 定义工作类worker:

worker继承 QThread, 重写run函数，在主线程中实例化worker，把耗时工作放进worker的run函数中完成，结束后，往主线程中发信号，传递参数即可。
注意：此worker的实例，只有run函数在子线程中执行，worker的其他函数，均在主线程中执行。
如果子线程已经start开启，run函数尚未运行完时，再次start，此时子线程不会有任何操作，run函数不会被重新调用，会继续执行run函数。

b, 定义工作类worker:

worker继承Qobject，在worker中完成耗时操作，并在主线程中 #include “worker.h”进来，随后，在主线程中New出几个子线程QThread，使用moveToThread()函数，把worker转移进入子线程，例如：

pWorker = new Worker;
pThread1 = new QThread;
pWorker->moveToThread(pThread1)

之后，再根据需求，看何时开启子线程：pThread1->start();
如果线程已经运行，你重复调用start其实是不会进行任何处理。

2、线程关闭

对于上面a类，在run中开启的子线程，如果run中没有调用exec()，使用quit(),exit()，是无法跳出run中的循环，终止子线程的。不会发生任何效果，QThread不会因为你调用quit()函数而退出正在运行到一半的run。
但使用QThread的terminate()方法，可以立刻结束子线程，但这个函数存在非常不安定因素，不推荐使用。那么如何安全的终止一个线程呢？

最简单的方法是添加一个bool变量，通过主线程修改这个bool变量来进行终止，但这样有可能引起访问冲突，需要对其进行加锁。

void myThread::run()
{
    int count = 0;
    m_isCanRun = true;//标记可以运行
    QString str = QString("%1->%2,thread id:%3").arg(__FILE__).arg(__FUNCTION__)
    .arg((unsigned int)QThread::currentThreadId());
    emit message(str);
    while(1)
    {
        sleep(1);
        ++count;    
        doSomething();
        if(m_runCount == count)
        {
            break;
        }

        {
            QMutexLocker locker(&m_lock);// 此处加锁,防止访问冲突
            if(!m_isCanRun)//在每次循环判断是否可以运行，如果不行就退出循环
            {
                return;
            }
        }
    }
}

因此在子线程的run函数的循环中遇到m_isCanRun的判断后就会退出run函数,继承QThread的函数在运行完run函数后就视为线程完成，会发射finish信号。

子线程指针，尽量不要去delete ，这样不安全。一般会绑定QObject::deleteLater()方法。

connect(pThread,&QThread::finished ,thread,&QObject::deleteLater);

线程结束后调用deleteLater来销毁分配的内存。

对于上面b类，在Qt4.8之后，Qt多线程的写法最好还是通过QObject来实现，和线程的交互通过信号和槽(实际上其实是通过事件)联系。

继承QObject多线程的方法线程的创建很简单，只要让QThread的start函数运行起来就行，但是需要注意销毁线程的方法: 在线程创建之后，这个QObject的销毁不应该在主线程里进行，而是通过deleteLater槽进行安全的销毁，因此，继承QObject多线程的方法在创建时有几个槽函数需要特别关注：

  • 一个是QThread的finished信号对接QObject的deleteLater使得线程结束后，继承QObject的那个多线程类会自己销毁
  • 另一个是QThread的finished信号对接QThread自己的deleteLater，这个不是必须，下面官方例子就没这样做:
class Worker : public QObject
{
    Q_OBJECT
    public slots:
    void doWork(const QString ¶meter) {
    QString result;
    /* ... here is the expensive or blocking operation ... */
    emit resultReady(result);
    }
signals:
    void resultReady(const QString &result);
};

class Controller : public QObject
{
    Q_OBJECT
    QThread workerThread;
public:
    Controller() {
    Worker *worker = new Worker;
    worker->moveToThread(&workerThread);
    connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);
    connect(this, &Controller::operate, worker, &Worker::doWork);
    connect(worker, &Worker::resultReady, this, &Controller::handleResults);
    workerThread.start();
    }
    ~Controller() {
    workerThread.quit();
    workerThread.wait();
    }
public slots:
    void handleResults(const QString &);
signals:
    void operate(const QString &);
};

使用QObject创建多线程的方法如下：

  • 写一个继承QObject的类，对需要进行复杂耗时逻辑的入口函数声明为槽函数
  • 此类在旧线程new出来，不能给它设置任何父对象
  • 同时声明一个QThread对象，在官方例子里，QThread并没有new出来，这样在析构时就需要调用- – QThread::wait()，如果是堆分配的话， 可以通过deleteLater来让线程自杀
  • 把obj通过moveToThread方法转移到新线程中，此时object已经是在线程中了
  • 把线程的finished信号和object的deleteLater槽连接，这个信号槽必须连接，否则会内存泄漏
  • 正常连接其他信号和槽（在连接信号槽之前调用moveToThread，不需要处理connect的第五个参数，否则就显示声明用Qt::QueuedConnection来连接）
  • 初始化完后调用’QThread::start()’来启动线程
  • 在逻辑结束后，调用QThread::quit退出线程的事件循环