QT多线程

Qt是一个跨平台的 C++图形用户界面应用程序框架，它提供了对多线程的支持。以下是使用Qt进行多线程编程的一些常见方法：

1. 使用QThread类：QThread是Qt中用于创建和管理线程的类。你可以创建一个QThread对象，并将其启动，然后在该线程中执行你的任务。

2. 使用QtConcurrent类：QtConcurrent提供了一种简洁的方式来在多个线程中执行任务。它提供了一些函数，如QtConcurrent::run，可以在后台线程中执行指定的函数。

3. 使用信号和槽：信号和槽是Qt中用于对象通信的机制。你可以在一个线程中发射信号，然后在另一个线程中接收该信号并执行相应的操作。

4. 使用线程池：Qt提供了一个线程池类QThreadPool，它可以帮助你管理多个线程。你可以将任务提交到线程池中，然后线程池会自动为你分配线程来执行任务。

1.创建一个QThread对象并启动它：

#include <QThread>
#include <QtWidgets/QApplication>

// 定义一个线程函数
void threadFunction() {
    // 在线程中执行的任务
    // 例如：读取文件、处理数据等
    qDebug() << "Thread running...";
}

int main(int argc, char* argv[]) {
    // 创建 QApplication 对象
    QApplication app(argc, argv);

    // 创建 QThread 对象
    QThread thread;

    // 将线程函数绑定到线程对象上
    thread.start(&threadFunction);

    // 等待线程完成
    thread.wait();

    // 退出应用程序
    app.exit();

    return 0;
}

输出结果：

Thread running...

在上述示例中，我们定义了一个名为threadFunction的线程函数，它打印一条消息"Thread running..."。然后，在main函数中，我们创建了一个QThread对象thread，并将线程函数绑定到该对象上。最后，我们使用start函数启动线程，并使用wait函数等待线程完成。

请注意，线程函数必须是void类型，并且它不能有返回值。如果需要在线程中返回值，可以使用信号和槽机制来实现。

2使用QtConcurrent在后台线程中执行任务：

#include <QtWidgets/QApplication>
#include <QtConcurrent/QtConcurrent>

// 定义一个线程函数
void threadFunction() {
    // 在线程中执行的任务
    // 例如：读取文件、处理数据等
    qDebug() << "Thread running...";
}

int main(int argc, char* argv[]) {
    // 创建 QApplication 对象
    QApplication app(argc, argv);

    // 使用 QtConcurrent::run 函数在后台线程中执行任务
    QtConcurrent::run(&threadFunction);

    // 继续执行主线程的任务
    // 例如：显示界面、处理用户输入等

    // 等待线程完成
    app.exec();

    return 0;
}

输出结果：

Thread running...

在上述示例中，我们使用QtConcurrent::run函数在后台线程中执行线程函数。QtConcurrent::run函数会在后台线程中启动线程函数，并返回一个QFuture对象，用于获取线程函数的返回值。在主线程中，我们可以继续执行其他任务，而线程函数会在后台线程中执行。当主线程需要获取线程函数的返回值时，可以使用QFuture对象的result函数来获取。

请注意，QtConcurrent::run函数会自动管理线程的创建和销毁，因此不需要手动创建和销毁线程对象。同时，QtConcurrent::run函数还提供了一些其他的参数，用于设置线程的优先级、栈大小等。

3.使用信号和槽在不同的线程中通信：

#include <QtWidgets/QApplication>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QWidget>
#include <QtCore/QThread>
#include <QtCore/QMutex>
#include <QtCore/QSemaphore>
#include <QtCore/QWaitCondition>

// 定义一个线程类
class Thread : public QThread {
public:
    // 构造函数
    Thread(QWidget* parent) : QThread(parent) {
        // 创建一个互斥锁
        mutex = new QMutex();
        // 创建一个信号量
        semaphore = new QSemaphore(0);
        // 创建一个等待条件
        waitCondition = new QWaitCondition();
    }

    // 重写虚函数 run
    void run() override {
        // 进入循环，等待信号量
        while (true) {
            // 等待信号量
            semaphore->acquire();

            // 获取互斥锁
            mutex->lock();

            // 处理数据
            // 例如：读取文件、处理数据等

            // 发送信号
            emit dataReady();

            // 释放互斥锁
            mutex->unlock();

            // 释放信号量
            semaphore->release();
        }
    }

    // 发送数据准备好的信号
    void sendData() {
        // 发送信号
        emit dataReady();
    }

    // 获取数据的函数
    void getData() {
        // 进入循环，等待数据准备好的信号
        while (true) {
            // 等待信号
            waitCondition->wait(mutex);

            // 获取数据
            // 例如：读取文件、处理数据等

            // 发送信号，通知主线程数据准备好
            emit dataReady();
        }
    }

private:
    // 互斥锁
    QMutex* mutex;
    // 信号量
    QSemaphore* semaphore;
    // 等待条件
    QWaitCondition* waitCondition;    
};

// 定义一个窗口类
class MainWindow : public QWidget {
public:
    // 构造函数
    MainWindow(QWidget* parent) : QWidget(parent) {
        // 创建一个按钮
        QPushButton* button = new QPushButton("发送数据", this);
        // 创建一个线程对象
        thread = new Thread(this);
        // 连接信号和槽
        connect(button, &QPushButton::clicked, this, &MainWindow::sendData);
        connect(thread, &Thread::dataReady, this, &MainWindow::getData);

        // 布局窗口
        QVBoxLayout* layout = new QVBoxLayout;
        layout->addWidget(button);
        setLayout(layout);
    }

private:
    // 发送数据的槽函数
    void sendData() {
        // 发送数据
        thread->sendData();
    }

    // 获取数据的槽函数
    void getData() {
        // 获取数据
        thread->getData();
    }

    // 线程对象
    Thread* thread;
};

int main(int argc, char* argv[]) {
    // 创建 QApplication 对象
    QApplication app(argc, argv);

    // 创建窗口对象
    MainWindow window;

    // 显示窗口
    window.show();

    // 进入事件循环
    app.exec();

    return 0;
}

4、使用线程池

线程池是一种管理线程的技术，它可以减少线程的创建和销毁次数，提高程序的性能。在 Qt 中，我们可以使用 QThreadPool 类来实现线程池。QThreadPool 是一个线程池类，它可以自动管理线程的创建和销毁，并且可以将任务分配给线程执行。

下面是一个使用 QThreadPool 类实现线程池的示例代码：

#include <QtCore>
#include <QtConcurrent>

int main() {
    // 创建一个线程池
    QThreadPool threadPool;

    // 提交一个任务到线程池
    QRunnable *runnable = new QRunnable();
    runnable->run() = []() {
        // 在这里编写任务的代码
        qDebug() << "Task 1";
    };
    threadPool.start(runnable);

    // 提交另一个任务到线程池
    runnable = new QRunnable();
    runnable->run() = []() {
        // 在这里编写任务的代码
        qDebug() << "Task 2";
    };
    threadPool.start(runnable);

    // 提交第三个任务到线程池
    runnable = new QRunnable();
    runnable->run() = []() {
        // 在这里编写任务的代码
        qDebug() << "Task 3";
    };
    threadPool.start(runnable);

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

    return 0;
}

运行上述代码，输出结果如下：

plaintext

Task 1
Task 2
Task 3

在上述代码中，我们首先创建了一个 QThreadPool 对象。然后，我们创建了三个 QRunnable 对象，并将它们的 run() 函数设置为要执行的任务代码。最后，我们使用 threadPool.start() 函数将这些任务提交到线程池，并使用 threadPool.waitForDone() 函数等待所有任务完成。

请注意，在使用线程池时，我们需要考虑任务的数量和线程池的大小。如果任务数量过多，可能会导致线程池溢出，从而影响程序的性能。因此，我们需要根据实际情况合理设置线程池的大小。