Qt实现线程封装

Qt实现线程封装

本文使用 QObject::moveToThread 方式实现Qt中的线程封装，适用于频繁与主线程通信的场景。

1 线程封装

1.1 工作者对象头文件(AsyncWorker.h)

#ifndef ASYNCWORKER_H
#define ASYNCWORKER_H

#include <QObject>
#include <QThread>
#include <QMutex>

class AsyncWorker : public QObject
{
    Q_OBJECT
public:
    explicit AsyncWorker(std::function<void()> function, int actionInterval, QObject *parent=nullptr)
        : QObject(parent)
        , m_function(function)
        , m_actionInterval(actionInterval)
        , m_stop(false)
    {

    }

    void stopWork()
    {
        setStop(true);
    }

public slots:
    void doWork() //槽函数作为任务入口
    {
        setStop(false);
        while (true)
        {
            //检查停止标志
            if (isStop())
            {
                break;
            }

            m_function();

            //检查停止标志
            if (isStop())
            {
                break;
            }

            QThread::msleep(m_actionInterval);
        }

        emit finished();
    }

signals:
    void finished();

private:
    bool isStop()
    {
        QMutexLocker locker(&m_mutex);
        return m_stop;
    }

    void setStop(bool stop)
    {
        QMutexLocker locker(&m_mutex);
        m_stop = stop;
    }

private:
    std::function<void()> m_function;
    int m_actionInterval;
    bool m_stop;
    QMutex m_mutex; //保护停止标志
};

#endif // ASYNCWORKER_H

1.2 线程帮助类头文件(AsyncWorkHelper.h)

#ifndef ASYNCWORKHELPER_H
#define ASYNCWORKHELPER_H

#include <QObject>
#include <QThread>
#include "AsyncWorker.h"

//线程帮助类(不可重复使用)
class AsyncWorkHelper final : public QObject
{
    Q_OBJECT
public:
    AsyncWorkHelper(std::function<void()> function, int actionInterval);
    ~AsyncWorkHelper();

    void start();
    void stop();

private:
    void getBrakeInfo();

private:
    AsyncWorker *m_asyncWorker;
    QThread *m_thread;
};

#endif // ASYNCWORKHELPER_H

1.3 线程帮助类实现(AsyncWorkHelper.cpp)

#include "AsyncWorkHelper.h"

AsyncWorkHelper::AsyncWorkHelper(std::function<void()> function, int actionInterval)
{
    m_thread = new QThread;
    m_asyncWorker = new AsyncWorker(function, actionInterval);
    m_asyncWorker->moveToThread(m_thread); //移动对象到新线程

    //连接信号槽
    connect(m_thread, &QThread::started, m_asyncWorker, &AsyncWorker::doWork);
    connect(m_asyncWorker, &AsyncWorker::finished, m_thread, &QThread::quit);
    connect(m_asyncWorker, &AsyncWorker::finished, m_asyncWorker, &QObject::deleteLater);
    connect(m_thread, &QThread::finished, m_thread, &QObject::deleteLater);
}

AsyncWorkHelper::~AsyncWorkHelper()
{

}

void AsyncWorkHelper::start()
{
    m_thread->start(); //启动线程
}

void AsyncWorkHelper::stop()
{
    m_asyncWorker->stopWork();
}

2 测试代码

2.1 主窗口头文件 (mainwindow.h)

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include "AsyncWorkHelper.h"

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

    void startAsyncWork();
    void stopAsyncWork();

private:
    void testAsyncWork();

private:
    AsyncWorkHelper *m_testWorkHelper;
};
#endif // MAINWINDOW_H

2.2 主窗口实现 (mainwindow.cpp)

#include <QDateTime>
#include <QDebug>
#include "mainwindow.h"

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    std::function<void()> testAsyncWorkFunc = std::bind(&MainWindow::testAsyncWork, this);
    m_testWorkHelper =  new AsyncWorkHelper(testAsyncWorkFunc, 1000); //1000ms
    startAsyncWork();
}

MainWindow::~MainWindow()
{
    stopAsyncWork();
    delete m_testWorkHelper;
}

void MainWindow::startAsyncWork()
{
    m_testWorkHelper->start();
}

void MainWindow::stopAsyncWork()
{
    m_testWorkHelper->stop();
}

void MainWindow::testAsyncWork()
{
    //获取当前日期时间
    QDateTime currentDateTime = QDateTime::currentDateTime();

    //输出完整日期时间
    qDebug() << "当前日期时间: " << currentDateTime.toString("yyyy-MM-dd hh:mm:ss.zzz");
}