Qt的多线程类

主要介绍一些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

QFuture 和 QFutureWatcher 是 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 的子类，可以方便地将任务提交到线程池中执行。

使用 QThreadPool 和 QRunnable 可以实现高效的并发编程，以下是简单的示例代码：

#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() 将任务提交到线程池中执行。在任务中实现的逻辑会在线程池中的某个线程中执行。

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

适用场景

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