如何在QThread之间传递数据？兼顾后台任务与GUI响应

嗨，其实Qt的信号槽机制不止支持线程到GUI的通信，线程之间的跨线程通信它同样能完美搞定！而且完全符合你“不中断原线程、不冻结GUI”的需求，下面给你两种最常用的实现方案：

方案一：直接用信号槽跨线程连接（最简单推荐） #

Qt的信号槽天生支持跨线程调度，只要原线程和新线程都是独立的QThread实例，信号发射后Qt会自动把数据投递到目标线程的事件循环中，全程线程安全，不需要你手动处理锁。

代码示例： #

1. 原数据收集线程类

#include <QThread>
#include <QByteArray>

class DataCollectorThread : public QThread
{
    Q_OBJECT
signals:
    // 定义传递最新数据的信号，参数就是你要传递的数据类型
    void newDataReady(const QByteArray& latestData);

protected:
    void run() override {
        // 你的后台循环：持续获取+存储数据，不允许中断
        while (!isInterruptionRequested()) {
            QByteArray rawData = fetchDataFromSource(); // 模拟获取数据
            storeDataToStorage(rawData); // 模拟存储数据
            
            // 发射信号，把最新数据传给新线程
            emit newDataReady(rawData);
            
            msleep(100); // 模拟数据获取间隔，根据实际情况调整
        }
    }

private:
    QByteArray fetchDataFromSource() {
        // 这里写你的数据获取逻辑
        return QByteArray("sample data");
    }

    void storeDataToStorage(const QByteArray& data) {
        // 这里写你的数据存储逻辑
        Q_UNUSED(data);
    }
};

2. 新数据处理线程类

#include <QThread>
#include <QByteArray>

class DataProcessorThread : public QThread
{
    Q_OBJECT
public slots:
    // 处理数据的槽函数，参数和信号保持一致
    void processLatestData(const QByteArray& data) {
        // 这里写你的数据处理逻辑，这个函数会在新线程的上下文执行
        // 完全不会阻塞原线程或GUI
        qDebug() << "Processing data in new thread:" << data;
    }

protected:
    void run() override {
        // 必须启动事件循环！否则槽函数无法被触发
        exec();
    }
};

3. 在主程序中连接并启动线程

#include <QCoreApplication>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    DataCollectorThread* collectorThread = new DataCollectorThread;
    DataProcessorThread* processorThread = new DataProcessorThread;

    // 连接信号槽：Qt会自动判断用队列连接（Qt::QueuedConnection）
    connect(collectorThread, &DataCollectorThread::newDataReady,
            processorThread, &DataProcessorThread::processLatestData);

    // 启动两个线程
    collectorThread->start();
    processorThread->start();

    return a.exec();
}

关键注意点： #

• 新线程必须调用exec()启动事件循环，否则槽函数永远不会被执行。
• 传递的数据要确保是可安全复制的类型，或者用QSharedPointer传递大型对象，避免浅拷贝问题。

方案二：用线程安全队列做中间缓冲区（适合批量/流速控制场景） #

如果需要更灵活地控制数据的处理节奏（比如批量处理、限流），可以用线程安全的队列作为数据中转：原线程往队列里塞数据，新线程从队列里取数据处理。

代码示例： #

1. 定义线程安全队列类

#include <QQueue>
#include <QMutex>
#include <QWaitCondition>
#include <QByteArray>

class ThreadSafeDataQueue {
private:
    QQueue<QByteArray> m_dataQueue;
    QMutex m_mutex;
    QWaitCondition m_notEmptyCondition;

public:
    // 原线程调用：往队列里添加数据
    void enqueueData(const QByteArray& data) {
        QMutexLocker locker(&m_mutex);
        m_dataQueue.enqueue(data);
        m_notEmptyCondition.wakeOne(); // 唤醒等待数据的处理线程
    }

    // 新线程调用：阻塞等待并取出数据
    QByteArray dequeueData() {
        QMutexLocker locker(&m_mutex);
        // 队列为空时，阻塞等待直到有数据
        while (m_dataQueue.isEmpty()) {
            m_notEmptyCondition.wait(&m_mutex);
        }
        return m_dataQueue.dequeue();
    }
};

2. 修改原收集线程

void DataCollectorThread::run() {
    ThreadSafeDataQueue* dataQueue = getSharedQueue(); // 假设全局或通过构造函数传入队列
    while (!isInterruptionRequested()) {
        QByteArray rawData = fetchDataFromSource();
        storeDataToStorage(rawData);
        
        // 把数据加入线程安全队列
        dataQueue->enqueueData(rawData);
        
        msleep(100);
    }
}

3. 修改新处理线程

void DataProcessorThread::run() {
    ThreadSafeDataQueue* dataQueue = getSharedQueue(); // 获取同一个队列
    while (!isInterruptionRequested()) {
        // 阻塞等待数据，拿到后立即处理
        QByteArray data = dataQueue->dequeueData();
        processData(data);
    }
}

关键注意点： #

• 要确保两个线程使用的是同一个队列实例，可以通过构造函数传递或者全局管理。
• 用QMutexLocker自动管理互斥锁，避免死锁。
• 如果需要优雅退出处理线程，可以额外加一个退出标志位，或者在队列中加入“结束标记”。

不管用哪种方案，都能保证原线程的后台任务不被中断，GUI也不会冻结——因为数据处理完全在新线程中完成。

内容的提问来源于stack exchange，提问作者Jim