QT多线程使用

Qt 多线程编程教程

在 Qt 中，多线程编程可以通过多种方式来实现。本文将介绍两种主要的多线程编程方法：使用 QtConcurrent 和 QThreadPool。

1. 使用 QtConcurrent

QtConcurrent 提供了一种高层次的 API，用于简化多线程操作。它能够自动管理线程池和任务的调度，使得多线程编程更加直观和简洁。

1.1 QtConcurrent::run

• 作用：用于将任务提交到全局线程池中执行，并返回一个 QFuture 对象，表示异步操作的结果。
• 适用场景：适合简单任务和快速实现。

示例：

#include 
#include 
#include 

int task(int x) {
    QThread::sleep(1); // 模拟耗时操作
    return x * x;
}

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

    QList<int> inputs = {1, 2, 3, 4, 5};
    QList<QFuture<int>> futures;

    // 提交多个任务
    for (int input : inputs) {
        QFuture<int> future = QtConcurrent::run(task, input);
        futures.append(future);
    }

    // 等待所有任务完成
    for (QFuture<int> &future : futures) {
        future.waitForFinished();
        qDebug() << "Result:" << future.result();
    }

    return 0;
}

1.2 QFuture

• 作用：表示异步操作的结果，可以用来检查任务状态、获取结果等。
• 创建：通常通过 QtConcurrent::run 或 QtConcurrent::map 等函数获得。

示例：

#include 
#include 
#include 

int compute(int x) {
    QThread::sleep(2); // 模拟耗时操作
    return x * x;
}

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

    QFuture<int> future = QtConcurrent::run(compute, 5);
    future.waitForFinished(); // 等待任务完成

    qDebug() << "Result:" << future.result(); // 获取结果

    return 0;
}

1.3 QFutureWatcher

• 作用：监视 QFuture 对象的状态，并在任务完成时发出信号。
• 适用场景：适合与 UI 交互时使用。

示例：

#include 
#include 
#include 
#include 

int compute(int x) {
    QThread::sleep(2); // 模拟耗时操作
    return x * x;
}

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

    QFuture<int> future = QtConcurrent::run(compute, 5);
    QFutureWatcher<int> watcher;
    
    QObject::connect(&watcher, &QFutureWatcher<int>::finished, [&]() {
        qDebug() << "Result:" << watcher.result();
    });

    watcher.setFuture(future); // 将 QFuture 对象与 QFutureWatcher 关联

    return app.exec();
}

1.4 QFutureIterator

• 作用：用于遍历 QFuture 对象的结果，适合处理多个结果的场景。
• 创建：创建 QFutureIterator 实例并传入 QFuture 对象。

示例：

#include 
#include 
#include 
#include 

int compute(int x) {
    QThread::sleep(1); // 模拟耗时操作
    return x * x;
}

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

    QList<int> inputs = {1, 2, 3, 4, 5};
    QFuture<int> future = QtConcurrent::mapped(inputs, compute);
    
    QFutureIterator<int> it(future);
    
    while (it.hasNext()) {
        qDebug() << "Result:" << it.next();
    }

    return 0;
}

1.5 QFutureSynchronizer

• 作用：用于同步多个 QFuture 对象，确保所有任务完成后再处理结果。
• 适用场景：适合需要同时处理多个任务结果的场景。

示例：

#include 
#include 
#include 
#include 
#include 

int compute(int x) {
    QThread::sleep(1); // 模拟耗时操作
    return x * x;
}

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

    QList<int> inputs = {1, 2, 3, 4, 5};
    QFutureSynchronizer<int> synchronizer;

    foreach (int input, inputs) {
        QFuture<int> future = QtConcurrent::run(compute, input);
        synchronizer.addFuture(future);
    }

    synchronizer.waitForFinished(); // 等待所有任务完成

    // 获取并输出所有任务的结果
    foreach (const QFuture<int>& future, synchronizer.futures()) {
        qDebug() << "Result:" << future.result();
    }

    return 0;
}

2. 使用 QThreadPool 和 QRunnable

QThreadPool 提供了一个线程池的实现，你可以提交多个 QRunnable 任务到线程池中。与 QtConcurrent 相比，QThreadPool 提供了更大的灵活性和控制，但需要更多的代码来设置。

2.1 QThreadPool 和 QRunnable

• 作用：QThreadPool 管理多个线程，QRunnable 代表一个可执行的任务。
• 自定义任务：你需要定义一个继承自 QRunnable 的类，并实现 run() 方法。

示例：

#include 
#include 
#include 
#include 

class Task : public QRunnable {
public:
    Task(int x) : m_x(x) {}

    void run() override {
        QThread::sleep(1); // 模拟耗时操作
        qDebug() << "Task" << m_x << "is running in thread:" << QThread::currentThreadId();
    }

private:
    int m_x;
};

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

    QThreadPool pool;
    pool.setMaxThreadCount(4); // 设置最大线程数

    QList<int> inputs = {1, 2, 3, 4, 5};

    // 提交多个任务到线程池
    for (int input : inputs) {
        Task *task = new Task(input);
        pool.start(task);
    }

    pool.waitForDone(); // 等待所有任务完成

    qDebug() << "All tasks finished!";
    return 0;
}

总结

• QtConcurrent::run：用于简单任务的快速实现，无需定义额外任务类。
• QFuture：管理异步任务的结果。
• QFutureWatcher：监视任务状态，并在任务完成时发出信号。
• QFutureIterator：遍历多个结果。
• QFutureSynchronizer：同步多个 QFuture 对象，确保所有任务完成后再处理结果。
• QThreadPool 和 QRunnable：提供更大的灵活性和控制，适合需要自定义任务和线程池设置的场景。