Qt 创建和管理线程的方法

Qt 提供了几种创建和管理线程的方法，主要包括以下几种：

1. **QThread**：这是Qt中最常用的线程类。使用QThread可以创建一个独立的线程，并在其中运行一个事件循环。通常与`QObject`的子类配合使用，该子类重写了`run()`方法。

    ```cpp
    #include <QThread>
    #include <QDebug>

    class MyThread : public QThread
    {
    public:
        void run() override {
            // 线程执行的代码
            qDebug() << "Thread is running";
        }
    };

    int main()
    {
        MyThread thread;
        thread.start(); // 启动线程
        thread.wait();  // 等待线程结束
        return 0;
    }
    ```

2. **std::thread (C++11 标准库线程)**：Qt支持C++11标准库中的线程，可以使用`std::thread`来创建和管理线程。

    ```cpp
    #include <iostream>
    #include <thread>

    void threadFunction() {
        std::cout << "Thread function running" << std::endl;
    }

    int main() {
        std::thread t(threadFunction);
        t.join(); // 等待线程结束
        return 0;
    }
    ```

3. **QThreadPool**：这是一个管理线程池的类，可以重复使用线程来执行任务，而不是为每个任务创建和销毁线程。

    ```cpp
    #include <QThreadPool>
    #include <QRunnable>
    #include <QDebug>

    class Task : public QObject, public QRunnable
    {
    public:
        void run() override {
            qDebug() << "Task is running";
        }
    };

    int main()
    {
        QThreadPool::globalInstance()->start(new Task());
        return 0;
    }
    ```

4. **QtConcurrent**：这是一个简化并行编程的模块，允许你使用简单的函数调用来启动并行任务。

    ```cpp
    #include <QtConcurrent>
    #include <QDebug>

    int myFunction() {
        qDebug() << "Function running in parallel";
        return 42;
    }

    int main() {
        auto result = QtConcurrent::run(myFunction);
        qDebug() << "Result:" << result.result();
        return 0;
    }
    ```

5. **Worker-Thread Pattern**：这是一种设计模式，通常结合信号和槽使用，允许你在工作线程中执行长时间运行的任务，并通过Qt的信号和槽机制与主线程通信。

    ```cpp
    // 假设有一个Worker类，它在单独的线程中运行
    class Worker : public QObject
    {
        Q_OBJECT
    public slots:
        void process() {
            // 执行任务
            emit resultReady(42);
        }
    signals:
        void resultReady(int result);
    };

    // 在主线程中

    QThread thread;
    Worker *worker = new Worker;
    worker->moveToThread(&thread); // 将worker移动到新线程
    connect(&thread, &QThread::started, worker, &Worker::process);
    connect(worker, &Worker::resultReady, [](int result) {
        qDebug() << "Result:" << result;
    });
    thread.start();
    ```

每种方法都有其适用场景，你可以根据实际需求选择最合适的线程创建和管理方式。