详解Qt中使用线程

Qt中的线程相关知识涵盖了线程创建、管理、通信以及线程安全等方面。下面将详细讲解这些知识点，并提供对应的示例代码。

线程创建与管理

QThread类

Qt通过QThread类来创建和管理线程。要创建一个新的工作线程，通常有两种方法：

方法一：直接创建QThread子类

创建一个继承自QThread的类，并重写run()方法来指定线程执行的任务。

class MyThread : public QThread {Q_OBJECTpublic:explicit MyThread(QObject *parent = nullptr) : QThread(parent) {}protected:void run() override {// 在这里编写线程执行的任务for (int i = 0; i < 100; ++i) {qDebug() << "Thread working: " << i;msleep(100); // 模拟耗时任务}}
};// 使用示例
MyThread *thread = new MyThread(this);
thread->start(); // 启动线程

方法二：使用工作对象与QThread配合

创建一个实现了run()方法的工作类，并将其移入QThread实例中。这种方法更符合“单一职责原则”，将线程管理与线程任务分离。

class Worker : public QObject {Q_OBJECTpublic:explicit Worker(QObject *parent = nullptr) : QObject(parent) {}public slots:void run() {// 在这里编写线程执行的任务for (int i = 0; i < 100; ++i) {qDebug() << "Worker running: " << i;msleep(100); // 模拟耗时任务}}
};// 使用示例
QThread *thread = new QThread(this);
Worker *worker = new Worker();
worker->moveToThread(thread); // 将工作对象移入线程connect(thread, &QThread::started, worker, &Worker::run); // 当线程启动时，触发工作对象的run()方法
connect(worker, &QObject::destroyed, thread, &QThread::quit); // 工作对象销毁时，让线程退出
connect(thread, &QThread::finished, thread, &QObject::deleteLater); // 线程结束后删除线程对象thread->start(); // 启动线程

线程通信与同步

实际使用线程过程中，我们将很大的精力用在线程通信与同步中。接下来详细说一下。

信号与槽

Qt的信号槽机制支持跨线程通信。当一个线程中的对象发出信号时，连接到该信号的槽函数可以在另一个线程中执行。由于信号槽机制内部已经处理了线程同步问题，因此它是线程间安全的数据交换方式。

class Worker : public QObject {Q_OBJECTQ_PROPERTY(int progress READ getProgress NOTIFY progressChanged)public:explicit Worker(QObject *parent = nullptr) : QObject(parent), m_progress(0) {}int getProgress() const { return m_progress; }public slots:void processData() {for (int i = 0; i <= 100; ++i) {m_progress = i;emit progressChanged(i);msleep(100); // 模拟耗时任务}}signals:void progressChanged(int value);private:int m_progress;
};// 主线程中接收进度更新
connect(worker, &Worker::progressChanged, this, [this](int value) {ui->progressBar->setValue(value);
});// 启动工作线程
QThread *thread = new QThread(this);
Worker *worker = new Worker();
worker->moveToThread(thread);
connect(thread, &QThread::started, worker, &Worker::processData);
thread->start();

互斥锁（QMutex）、信号量（QSemaphore）与条件变量（QWaitCondition）

对于更复杂的线程同步需求，可以使用Qt提供的同步机制：

QMutex用于保护临界区，防止多个线程同时访问同一块数据。
QSemaphore用于控制同时访问共享资源的线程数量。
QWaitCondition允许线程在特定条件不满足时挂起自己，直到条件满足后再被唤醒。

QMutex使用示例

QMutex是用来实现线程同步的一种工具，它可以确保同一时间内只允许一个线程访问受保护的资源。下面是一个简单的QMutex使用例子，展示如何在两个线程中安全地访问和修改共享资源：

#include <QCoreApplication>
#include <QThread>
#include <QDebug>
#include <QMutex>class SharedResource : public QObject {Q_OBJECT
public:explicit SharedResource(QObject *parent = nullptr) : QObject(parent), count(0), mutex(new QMutex()) {}void increment() {mutex->lock();count++;qDebug() << "Count incremented from thread:" << QThread::currentThreadId();mutex->unlock();}int getCount() const {QMutexLocker locker(mutex.get());return count;}private:int count;QSharedPointer<QMutex> mutex;
};// 工作线程类
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 < 100; ++i) {resource->increment();msleep(100); // 模拟耗时操作}}private:SharedResource *resource;
};int main(int argc, char *argv[])
{QCoreApplication app(argc, argv);// 创建共享资源SharedResource sharedResource;// 创建并启动两个工作线程WorkerThread thread1(&sharedResource);WorkerThread thread2(&sharedResource);thread1.start();thread2.start();// 等待两个线程都完成thread1.wait();thread2.wait();qDebug() << "两个线程结束后，count最终值为:" << sharedResource.getCount();return app.exec();
}#include "main.moc"

在这个例子中，定义了一个名为SharedResource的类，其中包含一个整型变量count，并且使用了一个QMutex来保护这个变量。在increment()方法中加锁解锁来保证线程安全地递增count值。

此外，创建了一个名为WorkerThread的线程类，它在运行时会调用SharedResource的increment()方法。启动两个WorkerThread实例，它们会在各自的线程中同时尝试增加count的值，但由于QMutex的存在，这两个线程会交替访问并修改count，确保了数据的安全性。

最后，主线程等待所有工作线程完成后，输出最终的count值，展示经过多线程并发操作后得到的结果

QSemaphore使用示例

QSemaphore在Qt中用于管理有限的资源，它主要用于解决生产者-消费者问题、控制访问许可的数量以及其他类型的并发控制场景。下面是一个简化的QSemaphore使用例子，模拟了一个生产者线程向缓冲区写入数据，消费者线程从缓冲区读取数据的过程：

#include <QCoreApplication>
#include <QThread>
#include <QSemaphore>
#include <QDebug>// 缓冲区大小
const int BufferSize = 10;// 循环缓冲区
char buffer[BufferSize];
QSemaphore freeSlots(BufferSize); // 初始化空闲槽数量为缓冲区大小
QSemaphore usedSlots(0); // 初始化已使用槽数量为0// 生产者线程类
class Producer : public QThread {
public:void run() override {while (true) {freeSlots.acquire(); // 请求一个空闲槽位// 这里省略了实际数据生产的代码buffer[index] = 'P'; // 假设生成一个字符数据usedSlots.release(); // 释放一个槽位，表示已填充数据qDebug() << "Producer produced data at index:" << index;index = (index + 1) % BufferSize;msleep(100); // 模拟生产延迟}}private:int index = 0;
};// 消费者线程类
class Consumer : public QThread {
public:void run() override {while (true) {usedSlots.acquire(); // 请求一个已使用槽位// 这里省略了实际数据消耗的代码qDebug() << "Consumer consumed data at index:" << index;freeSlots.release(); // 释放一个槽位，表示已消费数据index = (index + 1) % BufferSize;msleep(200); // 模拟消费延迟}}
};int main(int argc, char *argv[])
{QCoreApplication app(argc, argv);Producer producer;Consumer consumer;producer.start();consumer.start();producer.wait();consumer.wait();return app.exec();
}#include "main.moc"

在这个例子中：

我们创建了两个信号量：freeSlots代表缓冲区中可用的空闲位置数量，初始化为缓冲区大小；usedSlots代表已被占用的位置数量，初始化为0。
生产者线程每次运行时，首先获取一个空闲槽位（freeSlots.acquire()），然后假定填入数据，之后释放一个已使用槽位（usedSlots.release()）。
消费者线程则相反，首先获取一个已使用槽位（usedSlots.acquire()），接着假定消费掉数据，然后释放一个空闲槽位（freeSlots.release()）。

通过这种方式，QSemaphore确保了任何时候缓冲区中被占用的槽位不超过其容量，同时也确保了生产者不会在没有空闲槽位的情况下继续生产，消费者也不会在没有数据可消费的情况下继续消费。

注意，这个例子为了简洁起见省略了一些细节，比如实际的数据生产和消费过程，以及线程安全的索引管理等。在实际项目中，还需根据具体情况进行适当的错误处理和边界条件检查。

QWaitCondition使用示例

QWaitCondition在Qt中用于线程间的同步，当某个条件不满足时，线程可以进入等待状态，直到另一个线程改变了条件并唤醒等待的线程。下面是一个简化的QWaitCondition使用示例，模拟了一个生产者线程向队列添加数据，消费者线程从队列移除数据，并且在队列为空时消费者线程会等待生产者线程添加数据的情况：

#include <QThread>
#include <QWaitCondition>
#include <QMutex>
#include <QQueue>QQueue<int> dataQueue;
QMutex queueMutex;
QWaitCondition dataAvailable;class Producer : public QThread {
public:void run() override {for (int i = 0; i < 100; ++i) {queueMutex.lock();if (dataQueue.isEmpty()) {qDebug() << "Producing data: " << i;dataQueue.enqueue(i);// 数据已添加，通知消费者线程数据可用dataAvailable.wakeOne();}queueMutex.unlock();// 模拟生产延迟msleep(100);}}
};class Consumer : public QThread {
public:void run() override {forever {queueMutex.lock();while (dataQueue.isEmpty()) {// 队列为空，消费者线程等待数据dataAvailable.wait(&queueMutex);}if (!dataQueue.isEmpty()) {int value = dataQueue.dequeue();qDebug() << "Consuming data: " << value;}queueMutex.unlock();// 模拟消费延迟msleep(50);}}
};int main(int argc, char *argv[])
{QCoreApplication app(argc, argv);Producer producer;Consumer consumer;producer.start();consumer.start();producer.wait();// 在实际情况中，可能需要更好的机制来终止消费者线程，例如通过信号或中断循环return app.exec();
}#include "main.moc"

在这个例子中：

定义了一个受保护的队列dataQueue和一个互斥量queueMutex来保证对队列操作的线程安全性。
使用QWaitCondition实例dataAvailable来同步生产者和消费者线程。
生产者线程在循环中向队列添加数据，并在数据添加后调用dataAvailable.wakeOne()来唤醒至少一个等待的消费者线程。
消费者线程在循环中尝试从队列中取出数据，如果发现队列为空，则调用dataAvailable.wait(&queueMutex)进入等待状态，直到收到生产者线程的通知。

通过这样的方式，生产者和消费者能够有效地同步工作，消费者不会在无数据可消费时浪费CPU资源，而是会等待生产者准备好数据后再继续执行。

线程安全与资源管理

线程安全

在多线程环境下，访问共享数据时必须确保线程安全。常见的策略有：

互斥访问：使用QMutex、QReadWriteLock等工具保护临界区。
无状态函数：设计线程任务函数不依赖任何外部状态，仅接受参数和返回结果。
线程本地存储：使用QThreadStorage存储线程私有数据，避免数据竞争。

资源管理

线程生命周期：确保线程在完成任务后能正常退出，并清理相关资源。如使用QThread::wait()等待线程结束，或在工作类的析构函数中调用QThread::quit()和QThread::wait()。
异常处理：在线程任务函数中妥善处理异常，防止因异常导致线程无法正常退出。

使用建议

避免过度线程化：过多的线程可能导致上下文切换频繁，反而降低性能。根据任务性质和系统资源合理设置线程数量。
优先使用高级API：对于简单并行计算任务，考虑使用QtConcurrent库提供的函数（如QtConcurrent::run()、QtConcurrent::map()等），它们能自动管理线程池，简化编程。

综上，Qt提供了丰富的线程相关类和函数，帮助开发者实现多线程编程。通过正确使用这些工具，可以有效提升应用程序的响应速度、并发处理能力和资源利用率，同时需要注意线程安全、资源管理和线程间通信等问题。上述示例代码展示了创建线程、使用信号槽进行线程间通信以及线程同步的基本用法。