主要介绍一些Qt的多线程类

QThread

QThread 是 Qt 提供的基本的多线程类,它允许创建自定义的线程。可以继承 QThread 类,并重写其 run() 方法,在 run() 方法中编写线程要执行的代码。以下是一个简单的示例:

#include <QThread>
#include <QDebug>

class MyThread : public QThread {
public:
    void run() override {
        qDebug() << "MyThread is running";
        // 执行线程任务
    }
};

int main() {
    MyThread thread;
    thread.start(); // 启动线程
    thread.wait(); // 等待线程执行完毕
    return 0;
}

在这个示例中,我们创建了一个名为 MyThread 的自定义线程类,重写了 run() 方法,在其中编写线程要执行的任务。
然后在 main() 函数中创建了一个 MyThread 对象,并通过调用 start() 方法启动线程。

QtConcurrent

QtConcurrent 是 Qt 提供的高级并行编程框架,它简化了多线程编程,并提供了一组并行算法和容器。使用 QtConcurrent,可以很容易地并行执行任务,无需手动管理线程。以下是一个简单的示例:

#include <QtConcurrent/QtConcurrent>

void myFunction() {
    // 执行任务
}

int main() {
    // 并行执行任务
    QtConcurrent::run(myFunction);
    return 0;
}

在这个示例中,我们使用 QtConcurrent::run() 函数并行执行了一个函数 myFunction()

QFuture

QFutureQFutureWatcher 是 Qt 中用于处理异步操作的两个关键类,它们通常一起使用来实现异步编程模型。

  1. QFuture

    • QFuture 类似于 C++ 标准库中的 std::future,用于表示异步操作的结果。
    • 可以通过 QtConcurrent::run() 或者其他方式创建一个返回 QFuture 对象的异步操作,然后在需要的时候等待该操作完成并获取结果。
    • QFuture 提供了方法如 waitForFinished()result() 来等待异步操作完成和获取操作的结果。
  2. QFutureWatcher

    • QFutureWatcher 用于监视 QFuture 的状态变化,并在异步操作完成时发出信号。
    • 可以将 QFutureWatcher 与一个或多个 QFuture 关联,然后通过连接信号(如 finished() 信号)来处理异步操作的完成事件。
    • 这样,可以在异步操作完成后执行特定的逻辑,而不必主动轮询 QFuture 的状态。

示例代码如下:

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

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

    // 创建一个异步操作,返回 QFuture 对象
    QFuture<int> future = QtConcurrent::run([]() {
        qDebug() << "Async task is running in thread:" << QThread::currentThread();
        return 42;
    });

    // 创建一个 QFutureWatcher,并与 QFuture 关联
    QFutureWatcher<int> watcher;
    watcher.setFuture(future);

    // 连接信号,异步操作完成时执行特定逻辑
    QObject::connect(&watcher, &QFutureWatcher<int>::finished, [&]() {
        qDebug() << "Async task is finished, result:" << watcher.result();
        a.quit();
    });

    return a.exec();
}

在这个例子中,通过 QtConcurrent::run() 创建了一个异步操作并返回一个 QFuture 对象,然后创建了一个 QFutureWatcher 对象,并将其与 QFuture 关联。通过连接 finished() 信号,可以在异步操作完成时执行特定的逻辑。

QThreadPool

  1. QThreadPool
    QThreadPool 是 Qt 提供的线程池类,用于管理线程的执行。它可以在应用程序中创建一组线程,并在这些线程中执行任务。通过使用线程池,可以避免反复创建和销毁线程的开销,提高线程利用率和应用程序的性能。

  2. QRunnable
    QRunnable 是一个接口类,用于表示可以在线程池中执行的任务。它包含一个纯虚函数 run(),需要子类实现具体的任务逻辑。通过将任务实现为 QRunnable 的子类,可以方便地将任务提交到线程池中执行。

使用 QThreadPoolQRunnable 可以实现高效的并发编程,以下是简单的示例代码:

#include <QtConcurrent>
#include <QDebug>

class MyTask : public QRunnable {
public:
    void run() override {
        // 执行具体的任务逻辑
        qDebug() << "Task is running in thread:" << QThread::currentThread();
    }
};

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

    // 创建线程池
    QThreadPool pool;

    // 创建任务对象
    MyTask task;

    // 将任务提交到线程池中执行
    pool.start(&task);

    return a.exec();
}

以上代码中,创建了一个线程池 pool,并创建了一个任务对象 task,然后通过 pool.start() 将任务提交到线程池中执行。在任务中实现的逻辑会在线程池中的某个线程中执行。

使用 QThreadPoolQRunnable 可以方便地实现多线程编程,执行异步任务,提高应用程序的响应性和性能。

适用场景

  1. QThread:适合创建自定义线程。
  2. QtConcurrent:适合简单的并行和异步操作,能够快速地实现多线程编程。
  3. QFuture:适合需要对异步操作进行精细控制或者自定义状态传递的场景。
  4. QThreadPool:适合管理和执行任务,并提供了线程池的功能。
03-14 00:20