多线程
qt 多线程
1. Qt 多线程概述
在 Qt 中,多线程的处理⼀般是通过 QThread 类来实现。QThread 代表⼀个在应用程序中可以独立控制的线程,也可以和进程中的其他线程共享数据。QThread 对象管理程序中的⼀个控制线程。
2. QThread 常用 API
3. 使用线程
创建线程的步骤:
- 自定义一个类,继承于 QThread,并且只有⼀个线程处理函数(和主线程不是同⼀个线程),这个线程处理函数主要就是重写父类中的 run() 函数。
- 线程处理函数里面写入需要执行的复杂数据处理;
- 启动线程不能直接调用 run() 函数,需要使用对象来调用 start() 函数实现线程启动;
- 线程处理函数执行结束后可以定义⼀个信号来告诉主线程;
- 最后关闭线程。
示例代码:
1、首先新建 Qt 项目,设计 UI 界面如下,一个 label 和 PushButton:
2、新建一个类,继承于 QThread 类;
3、timethread.h 的程序如下:
#include <QThread>
class TimeThread : public QThread
{
Q_OBJECT
public:
TimeThread();
void run(); // 线程任务函数
signals:
void sendTime(QString Time); // 声明信号函数
};
4、widget.h 程序如下:
#include <QWidget>
#include <timethread.h>
QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE
class Widget : public QWidget
{
Q_OBJECT
public:
Widget(QWidget *parent = nullptr);
~Widget();
private slots:
void showTime(QString Time);
void on_pushButton_clicked();
private:
Ui::Widget *ui;
TimeThread t; // 定义线程对象
};
5、timethread.cpp 程序如下:
#include "timethread.h"
#include <QTime>
#include <QDebug>
TimeThread::TimeThread()
{}
void TimeThread::run()
{
while(1) {
QString time = QTime::currentTime().toString("hh:mm:ss");
qDebug() << time;
emit sendTime(time); // 发送信号
sleep(1);
}
}
-
widget.cpp 如下:
#include "widget.h" #include "ui_widget.h" Widget::Widget(QWidget *parent) : QWidget(parent) , ui(new Ui::Widget) { ui->setupUi(this); connect(&t, &TimeThread::sendTime, this, &Widget::showTime); } Widget::~Widget() { delete ui; } void Widget::showTime(QString Time) { ui->label->setText(Time); } void Widget::on_pushButton_clicked() { t.start(); // 开启线程 }
效果如下:
注意:
- 线程函数内部不允许操作 UI 图形界⾯,⼀般⽤数据处理;
- connect() 函数第五个参数表示的为连接的方式,且只有在多线程的时候才意义。
connect() 函数第五个参数为 Qt::ConnectionType,用于指定信号和槽的连接类型。同时影响信号的传递方式和槽函数的执行顺序。Qt::ConnectionType 提供了以下五种方式:
4. 线程安全
实现线程互斥和同步常用的类有:
- 互斥锁:QMutex、QMutexLocker
- 条件变量:QWaitCondition
- 信号量:QSemaphore
- 读写锁:QReadLocker、QWriteLocker、QReadWriteLock
(1)互斥锁
互斥锁是⼀种保护和防止多个线程同时访问同⼀对象实例的方法,在 Qt 中,互斥锁主要是通过 QMutex 类来处理。
- QMutex
特点:QMutex 是 Qt 框架提供的互斥锁类,用于保护共享资源的访问,实现线程间的互斥操作。
用途:在多线程环境下,通过互斥锁来控制对共享数据的访问,确保线程安全。
QMutex mutex;
mutex.lock(); //上锁
//访问共享资源
//...
mutex.unlock(); //解锁
- QMutexLocker
特点:QMutexLocker 是 QMutex 的辅助类,使用 RAII(Resource Acquisition Is Initialization)方式对互斥锁进⾏上锁和解锁操作。
用途:简化对互斥锁的上锁和解锁操作,避免忘记解锁导致的死锁等问题。
QMutex mutex;
{
QMutexLocker locker(&mutex); //在作⽤域内⾃动上锁
//访问共享资源
//...
} //在作⽤域结束时自动解锁
- QReadWriteLocker、QReadLocker、QWriteLocker
特点:
QReadWriteLock 是读写锁类,用于控制读和写的并发访问。
QReadLocker 用于读操作上锁,允许多个线程同时读取共享资源。
QWriteLocker 用于写操作上锁,只允许⼀个线程写⼊共享资源。
用途:在某些情况下,多个线程可以同时读取共享数据,但只有⼀个线程能够进行写操作。读写锁提供了更高效的并发访问方式。
QReadWriteLock rwLock;
//在读操作中使⽤读锁
{
QReadLocker locker(&rwLock); //在作⽤域内⾃动上读锁
//读取共享资源
//...
} //在作⽤域结束时⾃动解读锁
//在写操作中使⽤写锁
{
QWriteLocker locker(&rwLock); //在作⽤域内⾃动上写锁
//修改共享资源
//...
} //在作⽤域结束时⾃动解写锁
示例代码:
1、myThread.h 程序如下:
#include <QThread>
#include <QMutex>
class myThread : public QThread
{
Q_OBJECT
public:
explicit myThread(QObject* parent = nullptr);
void run();
private:
static QMutex mutex; // 多个线程使用一把锁
static int num; // 多个线程访问一个数据
};
2、myThread.cpp 程序如下:
#include "mythread.h"
#include <QDebug>
QMutex myThread::mutex;
int myThread::num = 0;
myThread::myThread(QObject* parent) : QThread(parent)
{}
void myThread::run()
{
while (1) {
this->mutex.lock(); // 加锁
qDebug() << "Current Thread: " << this << ", Value: " << this->num++;
this->mutex.unlock(); // 解锁
QThread::sleep(1); // 线程睡眠两秒
}
}
3、widget.h 程序如下:
class Widget : public QWidget
{
Q_OBJECT
public:
Widget(QWidget *parent = nullptr);
~Widget();
private:
Ui::Widget *ui;
};
4、widget.cpp 程序如下:
#include "widget.h"
#include "ui_widget.h"
#include "mythread.h"
Widget::Widget(QWidget *parent)
: QWidget(parent)
, ui(new Ui::Widget)
{
ui->setupUi(this);
myThread* t1 = new myThread(this);
myThread* t2 = new myThread(this);
t1->start();
t2->start();
}
执行效果如下,两个线程使用一把锁,操作⼀个数据,数据会被两个线程依次打印:0、1、2、3、4 …
示例代码2: 在上述示例的基础上使用 QMutexLocker 锁,只修改 myThread.cpp 即可:
#include "mythread.h"
#include <QDebug>
QMutex myThread::mutex;
int myThread::num = 0;
myThread::myThread(QObject* parent) : QThread(parent)
{}
void myThread::run()
{
while (1) {
//QMutexLocker:创建的时候加锁,当QMutexLocker局部销毁的时候解锁
{
QMutexLocker lock(&this->mutex);
qDebug() << "Current Thread: " << this << ", Value: " << this->num++;
}
QThread::sleep(1);
}
}
(2)条件变量
在多线程编程中,假设除了等待操作系统正在执行的线程之外,某个线程还必须等待某些条件满足才能执行,这时就会出现问题。这种情况下,线程会很自然地使用锁的机制来阻塞其他线程,因为这只是线程的轮流使用,并且该线程等待某些特定条件,人们会认为需要等待条件的线程,在释放互斥锁或读写锁之后进⼊了睡眠状态,这样其他线程就可以继续运行。当条件满足时,等待条件的线程将被另⼀个线程唤醒。
在 Qt 中,专门提供了 QWaitCondition 类来解决像上述这样的问题。
特点:QWaitCondition 是 Qt 框架提供的条件变量类,用于线程之间的消息通信和同步。
用途:在某个条件满足时等待或唤醒线程,用于线程的同步和协调。
简单的伪代码用法如下:
QMutex mutex;
QWaitCondition condition;
//在等待线程中
mutex.lock();
//检查条件是否满⾜,若不满⾜则等待
while (!conditionFullfilled())
{
condition.wait(&mutex); //等待条件满⾜并释放锁
}
//条件满⾜后继续执⾏
//...
mutex.unlock();
//在改变条件的线程中
mutex.lock();
//改变条件
changeCondition();
condition.wakeAll(); //唤醒等待的线程
mutex.unlock();
(3)信号量
有时在多线程编程中,需要确保多个线程可以相应的访问⼀个数量有限的相同资源。例如,运行程序的设备可能是非常有限的内存,因此我们更希望需要大量内存的线程将这一事实考虑在内,并根据可用的内存数量进行相关操作,多线程编程中类似问题通常用信号量来处理。信号量类似于增强的互斥锁,不仅能完成上锁和解锁操作,而且可以跟踪可用资源的数量。
特点:QSemaphore 是 Qt 框架提供的计数信号量类,用于控制同时访问共享资源的线程数量。
用途:限制并发线程数量,用于解决⼀些资源有限的问题。
QSemaphore semaphore(2); //同时允许两个线程访问共享资源
//在需要访问共享资源的线程中
semaphore.acquire(); //尝试获取信号量,若已满则阻塞
//访问共享资源
//...
semaphore.release(); //释放信号量
//在另⼀个线程中进⾏类似操作
标签:Widget,include,QT,myThread,线程,mutex,多线程,Qt
From: https://blog.csdn.net/YoungMLet/article/details/140281319