详解Qt中使用线程
Qt中的线程相关知识涵盖了线程创建、管理、通信以及线程安全等方面。下面将详细讲解这些知识点，并提供对应的示例代码。
线程创建与管理
QThread类
Qt通过QThread类来创建和管理线程。要创建一个新的工作线程，通常有两种方法：
方法一：直接创建QThread子类
创建一个继承自QThread的类，并重写run()方法来指定线程执行的任务。
class MyThread : public QThread {
Q_OBJECT
public:
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_OBJECT
public:
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_OBJECT
Q_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提供了丰富的线程相关类和函数，帮助开发者实现多线程编程。通过正确使用这些工具，可以有效提升应用程序的响应速度、并发处理能力和资源利用率，同时需要注意线程安全、资源管理和线程间通信等问题。上述示例代码展示了创建线程、使用信号槽进行线程间通信以及线程同步的基本用法。
![[计算机效率] 文本编辑工具：Notepad++](https://img-blog.csdnimg.cn/direct/d8b258cac2604bd3921d715b689a78de.png)
