欢迎光临
我们一直在努力

Qt多线程第二部分_共享数据_锁

一、先讲:什么是 “共享数据”

  • 共享数据 = 多个线程(比如主线程、子线程)都能访问 / 修改的同一个变量 / 对象 / 资源

直观的共享数据

下面展示共享数据有哪些:

全局变量

// 全局变量:所有线程都能访问 → 共享数据
int g_score = 0;

// 子线程函数:修改g_score
void addScoreInThread() {
for(int i=0; i<1000; i++) {
g_score++; // 子线程修改共享数据
}
}//我这里特地备注一下,这个函数应该分文件编写到其它文件里边作为某个槽函数
//或者是在其它文件里边被子线程调用 我为了方便对比将其直接写到了同一块代码块

// 主线程:也修改g_score
int main() {
// 主线程自己改
for(int i=0; i<1000; i++) {
g_score++; // 主线程修改共享数据
}
return 0;
}

类的成员变量

#include <QThread>
// 定义一个类,成员变量是共享数据
class ScoreManager : public QObject
{
Q_OBJECT
public:
// 成员变量:主线程和子线程都能改 → 共享数据
int totalScore = 0;

// 子线程调用的函数:修改totalScore
void addScore() {
totalScore++;
}
};

内存四区中堆区的对象(也就是new出来的对象)

#include <QThread>
// 堆上创建的对象:多个线程都有指针指向它 → 共享数据
ScoreManager *manager = new ScoreManager();

// 子线程函数:通过指针修改manager里的totalScore
void threadFunc() {
manager->addScore(); // 子线程访问共享对象
}

既然子线程和主线程都能对一个对象进行操作访问,那么就会存在一种情况,比如,在同时进行主线程和子线程的情况下,两个线程都对同一个对象进行修改,这时候就会出数据竞争这种情况。
比如:

#include <QCoreApplication>
#include <QThread>
#include <QDebug>

// 共享数据:全局变量
int g_count = 0;

// 子线程函数:给g_count加10000次
void addCount() {
for(int i=0; i<10000; i++) {
g_count++; // 子线程修改共享数据
}
}

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

// 创建子线程,执行addCount
QThread thread;
QObject::connect(&thread, &QThread::started, [](){
addCount();
});
thread.start();

// 主线程也给g_count加10000次
addCount();

// 等子线程结束,打印结果
thread.wait();
qDebug() << "预期结果:20000,实际结果:" << g_count;

return 0;
}

所以我们需要用锁将共享数据保护起来,那么什么是锁?

锁的定义

  • 锁(互斥锁) = 用来保护共享数据的 “规则”
  • 某个线程要访问共享数据时,先 “上锁”;
  • 访问完后,“解锁”;
  • 上锁期间,其他线程想访问这个共享数据,必须等(阻塞),直到锁被解开

定义锁

  • 锁要和 “被保护的共享数据”同级别(比如共享数据是全局变量,锁也定义成全局的;共享数据是类成员,锁也定义成类成员);
  • 一个共享数据对应一个锁(比如保护 g_count 就定义一个 mutex_for_count)。
保护全局共享数据(定义全局锁)

#include <QMutex> // 必须包含这个头文件

// 共享数据
int g_count = 0;
// 定义锁:和共享数据同级别(全局)
QMutex g_mutex;

保护类成员共享数据(定义类成员锁)

#include <QObject>
#include <QMutex>

class ScoreManager : public QObject
{
Q_OBJECT
public:
// 共享数据
int totalScore = 0;
// 定义锁:类成员(保护totalScore)
QMutex scoreMutex;
};

用锁保护共享数据

使用锁的核心口诀:“上锁→操作共享数据→解锁”,Qt 里有 2 种用法(推荐第二种,更安全):

手动加锁 / 解锁

// 子线程函数:修改共享数据(加锁保护)
void addCount() {
for(int i=0; i<10000; i++) {
// 1. 上锁(关键!)
g_mutex.lock();

// 2. 操作共享数据(这一步只能有一个线程执行)
g_count++;

// 3. 解锁(必须解锁!否则其他线程永远等)
g_mutex.unlock();
}
}

自动加锁 / 解锁

手动解锁容易忘(比如函数提前 return,就会忘记 unlock,导致死锁),Qt 提供了QMutexLocker,会自动解锁

void addCount() {
for(int i=0; i<10000; i++) {
// 创建QMutexLocker对象时,自动上锁;函数结束/对象销毁时,自动解锁
QMutexLocker locker(&g_mutex);

// 操作共享数据
g_count++;

// 不用手动unlock!locker销毁时会自动解锁
}
}

这样自动解锁就安全了
示例:

#include <QCoreApplication>
#include <QThread>
#include <QDebug>
#include <QMutex> // 锁的头文件

// 共享数据
int g_count = 0;
// 定义锁(保护g_count)
QMutex g_mutex;

// 子线程函数:加锁保护共享数据
void addCount() {
for(int i=0; i<10000; i++) {
// 自动加锁/解锁
QMutexLocker locker(&g_mutex);
g_count++;
}
}

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

QThread thread;
QObject::connect(&thread, &QThread::started, [](){
addCount();
});
thread.start();

// 主线程也加锁修改
addCount();

thread.wait();
qDebug() << "预期结果:20000,实际结果:" << g_count;

return 0;
}

补充:加锁后要尽快解锁,加锁的代码块要 “短小”,比如只包住g_count++,不要把整个 for 循环都包住(会降低多线程效率)

另外,其实锁是能够复用的,我前面说一个共享数据用一个锁,只是我建议这么做,实在是要想一个锁保护多个不同的共享数据或者是一个锁在不同线程操作不同数据时复用,技术上是能够实现的,单项目上我不建议你这么做。

这就好比你家有两个厕所,你用A厕所,家里人用B厕所,但是门栓是一样的,你在使用A的时候,别人想用B也是不行的,也就是即使能同时用也得一个一个来,效率低下。(线程阻塞)

同时复用锁还很有可能导致死锁——简单说就是 “多个线程互相等对方解锁,谁都动不了”

线程阻塞的例子

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

QMutex g_mutex; // 唯一的锁

void thread1Func() {
qDebug() << "线程1:准备上锁";
g_mutex.lock(); // 步骤1:线程1上锁成功
qDebug() << "线程1:上锁成功,开始休眠100ms";

QThread::msleep(100); // 步骤2:线程1休眠(但锁还拿着!)

qDebug() << "线程1:休眠结束,准备解锁";
g_mutex.unlock(); // 步骤3:线程1解锁
qDebug() << "线程1:解锁成功,结束";
}

void thread2Func() {
qDebug() << "线程2:准备上锁";
g_mutex.lock(); // 步骤4:线程2尝试上锁(此时分两种情况)
qDebug() << "线程2:上锁成功";

g_mutex.unlock(); // 步骤5:线程2解锁
qDebug() << "线程2:解锁成功,结束";
}

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

QThread t1, t2;
QObject::connect(&t1, &QThread::started, thread1Func);
QObject::connect(&t2, &QThread::started, thread2Func);

qDebug() << "主线程:启动线程1";
t1.start();
qDebug() << "主线程:启动线程2";
t2.start();

t1.wait();
t2.wait();

qDebug() << "主线程:所有线程结束";
return 0;
}

死锁例子

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

// 复用的锁:既保护score,又保护count
QMutex g_mutex;
int g_score = 0;
int g_count = 0;

// 线程1:先改score,再改count(都用同一个锁)
void thread1Func() {
qDebug() << "线程1:准备改score,上锁";
g_mutex.lock(); // 线程1拿到锁
g_score++;
qDebug() << "线程1:改完score,准备等线程2改count(不解锁!)";

QThread::msleep(100); // 线程1拿着锁休眠,等线程2

qDebug() << "线程1:准备改count,再次上锁(复用同一个锁)";
g_mutex.lock(); // 坑!线程1想再次锁自己已经拿着的锁
g_count++;
g_mutex.unlock(); // 这行永远执行不到

g_mutex.unlock(); // 这行也永远执行不到
qDebug() << "线程1:结束";
}

// 线程2:先改count,再改score(都用同一个锁)
void thread2Func() {
qDebug() << "线程2:准备改count,上锁";
g_mutex.lock(); // 线程2等线程1解锁,但线程1永远不解锁
g_count++;
qDebug() << "线程2:改完count,准备改score";

g_mutex.lock(); // 这行永远执行不到
g_score++;
g_mutex.unlock();

g_mutex.unlock();
qDebug() << "线程2:结束";
}

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

QThread t1, t2;
QObject::connect(&t1, &QThread::started, thread1Func);
QObject::connect(&t2, &QThread::started, thread2Func);

t1.start();
t2.start();
t1.wait();
t2.wait();

qDebug() << "主线程:结束"; // 这行永远执行不到
return 0;
}

赞(0)
未经允许不得转载:171主机测评 » Qt多线程第二部分_共享数据_锁
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址