Qt多线程

Qt 提供了多种方式来处理多线程编程，它不仅使多线程操作更易于管理，还与 Qt 的事件驱动架构紧密集成。下面是 Qt 多线程编程的详细介绍，包括关键类、模式以及常见的使用场景。

1. 多线程编程的基础

在多线程编程中，程序同时运行多个线程，每个线程执行不同的任务。这在现代应用程序中非常重要，因为它可以提高性能，尤其是在处理 I/O 密集型任务、并行计算或需要保持 GUI 响应的情况下。

2. Qt 中的关键多线程类

Qt 提供了几个关键的类用于管理和控制线程：

• QThread：用于创建和管理线程的基本类。每个 QThread 对象表示一个线程。
• QMutex：用于线程之间的互斥，防止多个线程同时访问共享数据。
• QSemaphore：用于控制多个线程对共享资源的访问数量。
• QWaitCondition：允许线程在某个条件下等待，并在条件满足时继续执行。
• QThreadPool：用于管理一个线程池，可以将多个任务分配到一组线程中执行。
• QtConcurrent：提供了一组高级函数，用于轻松地进行并发编程，避免直接处理线程细节。
• QFuture 和 QFutureWatcher：与 QtConcurrent 一起使用，提供任务的结果和状态管理。

3. 使用 QThread

QThread 是 Qt 提供的用于创建和管理线程的基本类。可以通过两种主要方式使用 QThread：

3.1 继承 QThread

通过继承 QThread，可以重写其 run() 方法，在其中实现线程要执行的任务。
这种方式直接明了，但不推荐，因为它容易导致设计上的问题，特别是与 Qt 的信号和槽机制集成时。

class MyThread : public QThread
 {
protected:
    void run() override
     {
        // 在线程中执行的任务
        for (int i = 0; i < 10; ++i) 
        {
            qDebug() << "Running in thread" << QThread::currentThread();
            QThread::sleep(1);
        }
    }
};

// 使用
MyThread *thread = new MyThread();
thread->start();

3.2 使用 moveToThread

更推荐的做法是将一个 QObject 派生的类的实例移到一个 QThread 中执行任务。
这种方式更好地支持信号和槽机制，并且让 QObject 的生命周期与线程的生命周期解耦。

class Worker : public QObject
 {
    Q_OBJECT

public slots:
    void doWork()
     {
        for (int i = 0; i < 10; ++i) 
        {
            qDebug() << "Running in thread" << QThread::currentThread();
            QThread::sleep(1);
        }
        emit workFinished();
    }

signals:
    void workFinished();
};

// 使用
Worker *worker = new Worker();
QThread *thread = new QThread();

worker->moveToThread(thread);

QObject::connect(thread, &QThread::started, worker, &Worker::doWork);
QObject::connect(worker, &Worker::workFinished, thread, &QThread::quit);
QObject::connect(worker, &Worker::workFinished, worker, &QObject::deleteLater);
QObject::connect(thread, &QThread::finished, thread, &QObject::deleteLater);

thread->start();

4. QtConcurrent

QtConcurrent 是 Qt 提供的一个高级 API，允许轻松地将任务分派到多个线程中执行，而不需要手动管理线程生命周期。它支持以下功能：

• 并行处理集合：QtConcurrent::map、QtConcurrent::filter 和 QtConcurrent::reduce 可以用于对容器中的元素进行并行处理。
• 任务运行：QtConcurrent::run 允许将任何可调用对象（函数、成员函数、lambda）分配到线程中运行。

#include <QtConcurrent>
#include <QFuture>
#include <QFutureWatcher>
#include <QDebug>
#include <QCoreApplication>

void longTask()
 {
    for (int i = 0; i < 10; ++i) 
    {
        qDebug() << "Processing step" << i + 1;
        QThread::sleep(1);
    }
}

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

    QFuture<void> future = QtConcurrent::run(longTask);

    QFutureWatcher<void> watcher;
    QObject::connect(&watcher, &QFutureWatcher<void>::finished, []()
     {
        qDebug() << "Task finished.";
        QCoreApplication::quit();
    });

    watcher.setFuture(future);
    return app.exec();
}

5. 线程同步

当多个线程访问共享资源时，必须确保这些访问是同步的，以避免数据竞争和不一致。Qt 提供了几种工具来实现线程同步：

• QMutex：用于保护共享数据，使得在同一时刻只有一个线程能够访问这些数据。

  QMutex mutex;
  mutex.lock();
  // 访问共享数据
  mutex.unlock();
  

• QReadWriteLock：允许多个线程同时读取数据，但在写入数据时确保只有一个线程能进行操作。
• QSemaphore：允许一定数量的线程同时访问资源。
• QWaitCondition：用于让线程等待某个条件，并在条件满足时通知线程继续执行。

6. 线程池

QThreadPool 是一个线程池管理类，它允许您将多个任务分配给一组线程来执行。线程池通过重用线程来减少线程创建和销毁的开销。

QRunnable

QRunnable 是一个用于表示可运行任务的基类，它与 QThreadPool 搭配使用，可以实现将任务分配到线程池中执行。

QRunnable 的用途

QRunnable 是一个轻量级的类，用于定义需要在线程池中运行的任务。与直接使用 QThread 或 QThreadPool 不同，QRunnable 使得任务的定义和运行更为简单灵活。通过继承 QRunnable 并重写它的 run() 方法，可以定义一个具体的任务逻辑，然后将这个任务提交给 QThreadPool 执行。

关键点

• 继承 QRunnable：当一个类继承自 QRunnable 时，需要重写 run() 方法，这个方法会包含希望在后台线程中执行的代码。
• 配合 QThreadPool 使用：创建一个 QRunnable 对象后，可以将其交给 QThreadPool，后者会在空闲线程中执行这个任务。如果线程池中没有空闲线程，它会将任务排队，等待线程可用

QRunnable 的优势

• 轻量级：与 QThread 相比，QRunnable 更轻量级，不需要管理线程的生命周期。
• 高效的任务管理：配合 QThreadPool 使用，可以在不频繁创建销毁线程的情况下高效地管理和执行任务。
  灵活性：QRunnable 允许将任何任务封装成可运行的对象，并在需要时提交给线程池执行。

#include <QThreadPool>
#include <QRunnable>
#include <QDebug>

class MyTask : public QRunnable 
{
public:
    void run() override 
    {
        qDebug() << "Task running in thread" << QThread::currentThread();
    }
};

// 使用
QThreadPool *threadPool = QThreadPool::globalInstance();
MyTask *task = new MyTask();
threadPool->start(task);

7. 信号和槽机制在多线程中的应用

Qt 的信号和槽机制在多线程环境下依然有效，特别是当信号和槽位于不同的线程时，它们通过 Qt::QueuedConnection 来保证线程安全。

Qt::QueuedConnection：信号发射时，槽函数会被放入接收者线程的事件队列中，由接收者线程的事件循环执行。

8. 常见的多线程模式

• 生产者-消费者模式：使用 QQueue 和 QWaitCondition 来实现生产者-消费者模型，生产者线程产生数据并将其放入队列中，消费者线程从队列中取出数据进行处理。
• 任务并行模式：通过 QtConcurrent 或 QThreadPool 运行多个并行任务，尤其适用于需要并行处理数据的场景。
• GUI 线程与工作线程分离：将耗时任务放入工作线程中运行，以确保 GUI 线程始终保持响应。

9. 注意事项

• 线程安全：始终确保共享数据的访问是线程安全的，避免数据竞争。
• 不要直接操作 GUI：Qt 中的 GUI 元素只能在主线程（GUI 线程）中操作。如果需要从工作线程更新 GUI，请使用QMetaObject::invokeMethod 或通过信号和槽机制将更新请求发送到主线程。
• 避免死锁：特别是在使用多个互斥锁时，注意锁的获取顺序，避免死锁。