Qt常用多线程技术--moveToThread

---

前言

        我们在日常工作当中，经常需要处理一些耗时的任务，比如读取一个大文件、对界面的大量数据进行保存、把文件中的数据按保存时的时间的间隔回放到界面当中等等。如果这些工作放在主线程中处理，界面将会卡住，程序出现“无响应”，严重影响程序的使用。我们解决这种耗时任务的办法就是使用多线程技术，把耗时的任务分配给独立的线程去处理，主线程尽可能的只处理和用户交互的任务。我们现在的电脑，都是多CPU，电脑可以同时处理多个任务，我们把程序分解成主线程和多个子线程，可以充分利用电脑的处理能力，提高程序的执行效率。

---

一、Qt常用的多线程技术

使用Qt开发多年，使用最多的就是以下两种多线程技术：
1、继承QObject，使用moveToThread把工作对象移到子线程；
2、继承QThread，通过run函数，在子线程完成需要的工作。         这两种方法，都使用到了QThread，第一种方法是把一个工作对象完全移到QThread对象内，工作对象的槽函数都会在子线程内执行，而第二种方法，只有run函数是在子线程中执行，其他函数还是在主线程当中执行。所以，当我们需要一个工作对象能处理多种任务，希望这些任务在子线程中执行，那么我们应该使用第一种方法，如果只是执行一种任务，两种方法都可以。所以，我们更推荐第一种方法，它的扩展能力更好。

---

二、moveToThread实现回放功能

        我们通常使用子线程来完成耗时的任务，在主线程中只负责控制和显示。本文举的例子是工作当中数据回放功能的一个简化版本：读取一个文件，按文件内记录的时间间隔原样显示每一条记录。从工作场景中，我们知道，需要按记录之间的时间间隔回显每一条记录，必须在子线程中完成记录的处理，并在主线程中显示结果，如果不用子线程，所有工作都放在主线程中，那么在等待时间间隔这段时间，主线程必定是会卡主的，因为此时主线程已经挂起，所有的控制命令都得不到及时的响应。

三、代码实现

work类实现需要完成的任务，这里是负责处理帧数据，并根据帧间隔等待一段时间
work.h

#ifndef WORK_H
#define WORK_H

#include <QObject>
#include "type_defines.h"
#include <QVector>
#include <QString>

class Work : public QObject
{
    Q_OBJECT
public:
    explicit Work(QObject *parent = nullptr);

public slots:
    void do_playback(std::vector<frame_t*>* frame_vec);

signals:
    void to_show_messge(QString);

public slots:
};

#endif // WORK_H

work.cpp

#include "work.h"
#include <QDateTime>
#include <synchapi.h>

Work::Work(QObject *parent) : QObject(parent)
{

}

void Work::do_playback(std::vector<frame_t*>* frame_vec) {

    if (frame_vec == NULL || frame_vec->size() == 0) {
        return ;
    }

    frame_t* last_frame = NULL;//记录上一帧
    QString msg;

    for (int frame_index = 0; frame_index < frame_vec->size(); frame_index++) {
        frame_t* frame = frame_vec->at(frame_index);
        msg.clear();

        if (last_frame == NULL) {
            QDateTime current_date_time = QDateTime::currentDateTime();
            uint64_t current_timestamp = current_date_time.toMSecsSinceEpoch();//当前时间的时间戳
            msg.append(QString("%1 %2").arg(current_timestamp).arg(frame->frame_id));            
        } else {
            uint64_t interval = frame->timestamp - last_frame->timestamp;
            Sleep(interval);
            QDateTime current_date_time = QDateTime::currentDateTime();
            uint64_t current_timestamp = current_date_time.toMSecsSinceEpoch();//当前时间的时间戳
            msg.append(QString("%1 %2").arg(current_timestamp).arg(frame->frame_id));
        }

        last_frame = frame;
        emit to_show_messge(msg);
    }
}

主界面负责数据加载、控制回放和显示数据
mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QVector>
#include "type_defines.h"
#include <QThread>
#include "work.h"
#include <QString>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

private slots:
    void on_pushButtonLoad_clicked();

    void on_pushButtonPlayback_clicked();

public slots:
    void show_one_message(QString msg);
signals:
    void to_playback(std::vector<frame_t*>*);

private:
    Ui::MainWindow *ui;
    std::vector<frame_t*> m_frame_vec;//保存加载的帧数据
    QThread* m_work_thread;
    Work* m_work_obj;
};

#endif // MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    m_work_thread = new QThread;
    m_work_obj = new Work;
    m_work_obj->moveToThread(m_work_thread);

    connect(this, SIGNAL(to_playback(std::vector<frame_t*>*)), m_work_obj, SLOT(do_playback(std::vector<frame_t*>*)));
    connect(m_work_obj, SIGNAL(to_show_messge(QString)), this, SLOT(show_one_message(QString)));
    m_work_thread->start();
}

MainWindow::~MainWindow()
{
    delete ui;
    if (m_work_obj != NULL) {
        delete m_work_obj;
    }
}

void MainWindow::on_pushButtonLoad_clicked()
{
    //假设从文件中读取到了十行数据，时间戳单位是毫秒
    for (int i = 0; i < 10; i++) {
        frame_t* new_frame = new frame_t;
        new_frame->timestamp = i*1000;
        new_frame->frame_id = i;

        for (int data_index = 0; data_index < sizeof(new_frame->data); data_index++) {
            new_frame->data[0] = 0x1 + data_index;
        }

        m_frame_vec.push_back(new_frame);
    }
}

void MainWindow::on_pushButtonPlayback_clicked()
{
    emit to_playback(&m_frame_vec);
}

void MainWindow::show_one_message(QString msg) {
    ui->plainTextEdit->appendPlainText(msg);
}

四、运行结果

        根据加载的数据，数据间隔为1000毫秒，把这些数据回放到界面，也应该间隔1000毫秒。在实际运行结果中，我们可以看到，运行的结果是时间间隔略微比加载的数据时间间隔长一点，这个是正常的，因为处理数据，执行代码本身也消耗了一定的时间。如果我们把帧的时间间隔加大，会发现界面并没有卡顿的现象，说明在子线程中等待一段时间，并不影响主线程。

总结

Qt使用moveToThread实现多线程的技术使用要点总结：
1、工作类继承QObject；
2、类的第一行加宏：Q_OBJECT；
3、定义需要放在线程中执行的任务函数，如：do_playback
4、把工作类对象移入线程，如：m_work_obj->moveToThread(m_work_thread);
5、使用connect函数把控制信号和工作槽函数连接起来
6、启动线程。

class Work : public QObject
{
    Q_OBJECT
public:
    explicit Work(QObject *parent = nullptr);

public slots:
    void do_playback(std::vector<frame_t*>* frame_vec);

signals:
    void to_show_messge(QString);

public slots:
};

    m_work_thread = new QThread;
    m_work_obj = new Work;
    m_work_obj->moveToThread(m_work_thread);

    connect(this, SIGNAL(to_playback(std::vector<frame_t*>*)), m_work_obj, SLOT(do_playback(std::vector<frame_t*>*)));
    connect(m_work_obj, SIGNAL(to_show_messge(QString)), this, SLOT(show_one_message(QString)));
    m_work_thread->start();