Qt多线程的使用与注意事项

Qt作为成熟的跨平台C++框架，提供了完整的多线程支持。本文将深入探讨Qt多线程的核心用法、线程间通信机制、线程安全保护以及常见陷阱，帮助开发者写出高效稳定的多线程应用。

一、QThread的基本用法

1.1 继承QThread方式

最传统的做法是继承QThread并重写run()函数：

cpp 复制代码

class WorkerThread : public QThread {
    Q_OBJECT
protected:
    void run() override {
        // 这里是子线程的执行环境
        for (int i = 0; i < 100; ++i) {
            qDebug() << "Working in thread:" << currentThreadId();
            QThread::sleep(1);
        }
    }
};

使用时直接start()即可：

cpp 复制代码

WorkerThread *worker = new WorkerThread();
worker->start();

这种方式简单直接，但要注意：run()函数外的所有成员函数都在主线程执行，不要在run()中直接调用其他成员方法。

1.2 moveToThread方式（推荐）

这是Qt官方推荐的方式，通过将QObject移动到线程：

cpp 复制代码

class Worker : public QObject {
    Q_OBJECT
public slots:
    void doWork() {
        // 耗时操作在子线程执行
        QThread::sleep(2);
        emit workFinished("Done!");
    }
    
signals:
    void workFinished(const QString &result);
};

Worker *worker = new Worker();
QThread *thread = new QThread();

worker->moveToThread(thread);

connect(thread, &QThread::started, worker, &Worker::doWork);
connect(worker, &Worker::workFinished, this, &MyClass::onWorkFinished);

thread->start();

这种方式将工作对象和线程分离，职责更清晰，更容易管理生命周期。

1.3 QThreadPool与QRunnable

对于大量短期任务，QThreadPool提供了线程池管理：

cpp 复制代码

class MyTask : public QRunnable {
    void run() override {
        // 任务逻辑
        processData();
    }
};

QThreadPool *pool = QThreadPool::globalInstance();
MyTask *task = new MyTask();
task->setAutoDelete(true);
pool->start(task);

线程池自动管理线程数量（默认等于CPU核心数），避免频繁创建销毁线程的开销。

二、线程间通信

2.1 信号槽（Signal-Slot）

Qt的信号槽机制是线程安全的，这是Qt多线程最强大的特性：

cpp 复制代码

// 跨线程连接需要使用QueuedConnection
connect(worker, &Worker::resultReady, 
        this,   &MyClass::handleResult,
        Qt::QueuedConnection);

关键点：跨线程连接时，信号会在目标线程的事件循环中被处理，自动完成线程切换。

2.2 QMetaObject::invokeMethod

对于直接方法调用，提供了一种安全的异步调用方式：

cpp 复制代码

QMetaObject::invokeMethod(worker, "doWork",
                       Qt::QueuedConnection);

QMetaObject::invokeMethod(worker, "doWork",
                       Qt::BlockingQueuedConnection);  // 同步等待

Qt::BlockingQueuedConnection会阻塞调用线程，等待方法执行完成，但要小心死锁。

2.3 事件队列

每个QThread都有自己的事件循环，通过QCoreApplication::postEvent可以实现线程间通信：

cpp 复制代码

// 发送自定义事件到目标线程
QCoreApplication::postEvent(receiver, new CustomEvent(data));

// 在接收线程的event()中处理
bool CustomEvent::event(QEvent *event) {
    if (event->type() == MyEventType) {
        // 处理数据
        return true;
    }
    return QEvent::event(event);
}

三、线程安全保护

3.1 QMutex

互斥锁是最基础的同步原语：

cpp 复制代码

QMutex mutex;
QVariant sharedData;

void safeAccess() {
    QMutexLocker locker(&mutex);  // 自动加锁/解锁
    // 操作共享数据
    sharedData = computeValue();
}

最佳实践：始终使用QMutexLocker，它会在作用域结束时自动释放锁，即使发生异常。

3.2 QReadWriteLock

读写锁允许多读单写，提升并发性能：

cpp 复制代码

QReadWriteLock lock;
QString sharedData;

QString readData() {
    QReadLocker locker(&lock);
    return sharedData;
}

void writeData(const QString &data) {
    QWriteLocker locker(&lock);
    sharedData = data;
}

读操作之间不互斥，只有写操作互斥，适合读多写少的场景。

3.3 QSemaphore

信号量用于控制同时访问资源的数量：

cpp 复制代码

QSemaphore sem(2);  // 允许2个并发访问

void accessResource() {
    sem.acquire();
    // 使用共享资源
    sem.release();
}

3.4 QWaitCondition

条件变量用于线程间的等待和通知：

cpp 复制代码

QWaitCondition condition;
QMutex mutex;
bool ready = false;

void waitForReady() {
    QMutexLocker locker(&mutex);
    condition.wait(&mutex);  // 等待信号
}

void signalReady() {
    QMutexLocker locker(&mutex);
    ready = true;
    condition.wakeAll();  // 通知所有等待线程
}

四、常见注意事项

4.1 跨线程操作GUI

绝对禁止从子线程直接操作GUI控件：

cpp 复制代码

// ❌ 错误：子线程直接操作UI
void Worker::updateUI() {
    label->setText("Result");  // 可能崩溃！
}

// ✅ 正确：通过信号槽或invokeMethod
void Worker::updateUI() {
    emit resultReady("Result");  // 主线程槽函数更新UI
}

所有UI操作都必须在主线程执行，这是Qt GUI框架的基本要求。

4.2 避免死锁

死锁是多线程程序最棘手的问题：

cpp 复制代码

// ❌ 危险：可能死锁
QMutexLocker locker1(&mutex1);
QMutexLocker locker2(&mutex2);  // 如果另一个线程先锁mutex2

// ✅ 解决方案：始终按相同顺序加锁
void safeFunc1() {
    QMutexLocker locker(&mutex1);
    doWork1();
}

void safeFunc2() {
    QMutexLocker locker(&mutex1);  // 始终先锁mutex1
    doWork2();
}

4.3 线程生命周期管理

正确管理线程生命周期至关重要：

cpp 复制代码

class MyWorker : public QObject {
    Q_OBJECT
public:
    ~MyWorker() {
        // 清理工作
        requestInterruption();
        wait();  // 等待线程结束
    }
};

重要：在销毁QThread前必须调用wait()等待线程结束，或先调用quit()停止事件循环。

4.4 数据竞争

避免在没有保护的情况下访问共享数据：

cpp 复制代码

// ❌ 数据竞争
QList<int> dataList;

void writer() {
    dataList.append(1);  // 写
}

void reader() {
    int first = dataList.first();  // 读，无保护！
}

// ✅ 使用互斥锁保护
QReadWriteLock lock;

void writer() {
    QWriteLocker locker(&lock);
    dataList.append(1);
}

五、最佳实践总结

优先使用moveToThread：将工作对象与线程分离，职责清晰
跨线程通信用信号槽：Qt的信号槽机制天然线程安全
始终使用RAII风格的锁：QMutexLocker/QReadLocker/QWriteLocker
禁止子线程操作UI：所有GUI操作必须在主线程
正确管理线程生命周期：在析构或停止前调用wait()等待结束
减少锁的粒度：只保护必要的临界区，避免过度同步影响性能
优先使用线程池：对于大量短期任务，使用QThreadPool避免开销

Qt多线程编程虽然有一定复杂度，但掌握核心原则后可以写出高效稳定的多线程应用。记住：线程安全是首要原则，不要为了性能而牺牲正确性。