QT--多线程

在 Qt 中，多线程开发是一个常见的需求，尤其是在处理耗时操作（如文件 I/O、网络请求、复杂计算等）时，为了避免阻塞主线程（通常是 GUI 线程），可以使用多线程技术。Qt 提供了多种方式来实现多线程开发，包括 QThread、QRunnable 和 QtConcurrent。

1. 使用 `QThread` 实现多线程

QThread 是 Qt 中最常用的多线程类，它提供了创建和管理线程的基本功能。

1.1 创建一个自定义线程类

可以通过继承 QThread 并重写 run() 方法来创建一个自定义线程。

#include <QThread>
#include <QDebug>

class MyThread : public QThread {
    Q_OBJECT

public:
    MyThread(QObject *parent = nullptr) : QThread(parent) {}

protected:
    void run() override {
        qDebug() << "Thread is running...";
        for (int i = 0; i < 10; ++i) {
            qDebug() << "Count:" << i;
            QThread::msleep(500);  // 模拟耗时操作
        }
        qDebug() << "Thread finished.";
    }
};

1.2 启动线程

在主线程中创建并启动自定义线程。

#include <QCoreApplication>
#include "MyThread.h"

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

    MyThread thread;
    thread.start();  // 启动线程

    return app.exec();
}

1.3 线程的停止

可以通过调用 QThread::quit() 或 QThread::terminate() 来停止线程。

thread.quit();  // 请求线程退出
thread.wait();  // 等待线程结束

2. 使用 `moveToThread` 实现多线程

moveToThread 是一种更灵活的多线程实现方式，它允许将对象移动到另一个线程中执行。

2.1 创建一个工作对象

创建一个继承自 QObject 的工作对象，并定义槽函数。

#include <QObject>
#include <QDebug>
#include <QThread>

class Worker : public QObject {
    Q_OBJECT

public slots:
    void doWork() {
        qDebug() << "Worker thread is running...";
        for (int i = 0; i < 10; ++i) {
            qDebug() << "Count:" << i;
            QThread::msleep(500);  // 模拟耗时操作
        }
        qDebug() << "Worker thread finished.";
    }
};

2.2 将工作对象移动到线程中

在主线程中创建线程和工作对象，并将工作对象移动到线程中。

#include <QCoreApplication>
#include "Worker.h"

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

    QThread thread;
    Worker worker;

    worker.moveToThread(&thread);  // 将工作对象移动到线程中

    QObject::connect(&thread, &QThread::started, &worker, &Worker::doWork);
    QObject::connect(&worker, &Worker::finished, &thread, &QThread::quit);
    QObject::connect(&worker, &Worker::finished, &worker, &QObject::deleteLater);
    QObject::connect(&thread, &QThread::finished, &thread, &QThread::deleteLater);

    thread.start();  // 启动线程

    return app.exec();
}

3. 使用 `QRunnable` 和 `QThreadPool` 实现多线程

QRunnable 是一个轻量级的多线程接口，通常与 QThreadPool 一起使用，用于管理线程池。

3.1 创建一个 QRunnable 任务

继承 QRunnable 并实现 run() 方法。

#include <QRunnable>
#include <QDebug>

class MyTask : public QRunnable {
public:
    void run() override {
        qDebug() << "Task is running...";
        for (int i = 0; i < 10; ++i) {
            qDebug() << "Count:" << i;
            QThread::msleep(500);  // 模拟耗时操作
        }
        qDebug() << "Task finished.";
    }
};

3.2 使用 QThreadPool 管理任务

在主线程中创建任务并提交到线程池。

#include <QCoreApplication>
#include <QThreadPool>
#include "MyTask.h"

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

    MyTask *task = new MyTask();
    task->setAutoDelete(true);  // 任务完成后自动删除

    QThreadPool::globalInstance()->start(task);  // 提交任务到线程池

    return app.exec();
}

4. 使用 `QtConcurrent` 实现多线程

QtConcurrent 是 Qt 提供的高级多线程 API，适用于简单的并行计算任务。它不需要手动管理线程，而是自动使用线程池。

4.1 使用 QtConcurrent::run

QtConcurrent::run 可以轻松地将函数或方法放入另一个线程中执行。

#include <QCoreApplication>
#include <QtConcurrent/QtConcurrentRun>
#include <QDebug>

void myFunction() {
    qDebug() << "Function is running...";
    for (int i = 0; i < 10; ++i) {
        qDebug() << "Count:" << i;
        QThread::msleep(500);  // 模拟耗时操作
    }
    qDebug() << "Function finished.";
}

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

    QtConcurrent::run(myFunction);  // 在另一个线程中运行函数

    return app.exec();
}

4.2 使用 QtConcurrent::map 和 QtConcurrent::filter

QtConcurrent::map 和 QtConcurrent::filter 用于并行处理容器中的数据。

#include <QCoreApplication>
#include <QtConcurrent/QtConcurrentMap>
#include <QVector>
#include <QDebug>

void square(int &value) {
    value = value * value;
}

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

    QVector<int> numbers = {1, 2, 3, 4, 5};

    // 并行计算每个元素的平方
    QtConcurrent::map(numbers, square).waitForFinished();

    qDebug() << "Squared numbers:" << numbers;

    return app.exec();
}

5. 线程间通信

在多线程开发中，线程间通信是一个重要的问题。Qt 提供了以下几种方式来实现线程间通信：

5.1 使用信号与槽

信号与槽是 Qt 中实现线程间通信的主要方式。信号可以在一个线程中发出，槽可以在另一个线程中处理。

class Worker : public QObject {
    Q_OBJECT

public slots:
    void doWork() {
        qDebug() << "Worker is working...";
        emit workFinished();  // 发出信号
    }

signals:
    void workFinished();
};

5.2 使用 QMetaObject::invokeMethod

QMetaObject::invokeMethod 可以在不同线程中调用对象的方法。

QMetaObject::invokeMethod(worker, "doWork", Qt::QueuedConnection);

5.3 使用 `QMutex` 和 `QWaitCondition`

在多线程开发中，线程间共享资源时需要考虑线程安全问题。Qt 提供了 QMutex 和 QWaitCondition 来实现线程同步。

示例：使用 QMutex 保护共享资源

#include <QMutex>
#include <QThread>
#include <QDebug>

class SharedResource {
public:
    void increment() {
        QMutexLocker locker(&mutex);  // 自动锁定和解锁
        ++value;
        qDebug() << "Value:" << value;
    }

private:
    QMutex mutex;
    int value = 0;
};

class WorkerThread : public QThread {
    Q_OBJECT

public:
    WorkerThread(SharedResource *resource, QObject *parent = nullptr)
        : QThread(parent), resource(resource) {}

protected:
    void run() override {
        for (int i = 0; i < 10; ++i) {
            resource->increment();
            QThread::msleep(100);  // 模拟耗时操作
        }
    }

private:
    SharedResource *resource;
};

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

    SharedResource resource;
    WorkerThread thread1(&resource);
    WorkerThread thread2(&resource);

    thread1.start();
    thread2.start();

    thread1.wait();
    thread2.wait();

    return app.exec();
}

示例：使用 QWaitCondition 实现线程等待

#include <QMutex>
#include <QWaitCondition>
#include <QThread>
#include <QDebug>

class Producer : public QThread {
    Q_OBJECT

public:
    Producer(QMutex *mutex, QWaitCondition *condition, QObject *parent = nullptr)
        : QThread(parent), mutex(mutex), condition(condition) {}

protected:
    void run() override {
        for (int i = 0; i < 5; ++i) {
            QMutexLocker locker(mutex);
            qDebug() << "Producing item:" << i;
            condition->wakeAll();  // 唤醒消费者线程
            QThread::msleep(500);  // 模拟生产耗时
        }
    }

private:
    QMutex *mutex;
    QWaitCondition *condition;
};

class Consumer : public QThread {
    Q_OBJECT

public:
    Consumer(QMutex *mutex, QWaitCondition *condition, QObject *parent = nullptr)
        : QThread(parent), mutex(mutex), condition(condition) {}

protected:
    void run() override {
        for (int i = 0; i < 5; ++i) {
            QMutexLocker locker(mutex);
            condition->wait(mutex);  // 等待生产者线程唤醒
            qDebug() << "Consuming item:" << i;
        }
    }

private:
    QMutex *mutex;
    QWaitCondition *condition;
};

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

    QMutex mutex;
    QWaitCondition condition;

    Producer producer(&mutex, &condition);
    Consumer consumer(&mutex, &condition);

    consumer.start();
    producer.start();

    consumer.wait();
    producer.wait();

    return app.exec();
}

6. 多线程开发的注意事项

6.1 线程安全

在多线程环境中，访问共享资源时必须确保线程安全。可以使用 QMutex、QReadWriteLock 或 QSemaphore 来保护共享资源。

6.2 避免死锁

在使用锁时，避免嵌套锁定相同的锁，否则可能导致死锁。

6.3 线程优先级

可以使用 QThread::setPriority 设置线程的优先级，但需要注意优先级设置可能会影响系统性能。

6.4 线程池的使用

对于短生命周期的任务，建议使用 QThreadPool 来管理线程，避免频繁创建和销毁线程的开销。

6.5 跨线程的信号与槽

信号与槽是线程安全的，但需要注意槽函数的执行线程。默认情况下，槽函数会在信号发出的线程中执行。

7. 总结

Qt 提供了多种多线程开发的方式，开发者可以根据具体需求选择合适的方法：

方法	适用场景
`QThread`	需要手动管理线程生命周期和执行逻辑。
`moveToThread`	需要将对象移动到另一个线程中执行。
`QRunnable`	需要使用线程池管理短生命周期的任务。
`QtConcurrent`	需要简单的并行计算任务，无需手动管理线程。
`QMutex` 和 `QWaitCondition`	需要保护共享资源或实现线程同步。

在多线程开发中，线程安全、线程间通信和资源管理是关键问题。通过合理使用 Qt 提供的多线程工具，可以高效地实现并发编程，提升应用程序的性能和响应速度。

1. 使用 QThread 实现多线程

2. 使用 moveToThread 实现多线程

3. 使用 QRunnable 和 QThreadPool 实现多线程

4. 使用 QtConcurrent 实现多线程