chanong 关键资源：一次只允许一个线程访问的资源
线程之间的互斥：多个线程需要同时访问关键资源
线程锁可以保证关键资源的安全。 通常，每个关键资源都需要线程锁来保护。
线程死锁：线程之间互相等待关键资源，导致彼此无法继续执行。
造成死锁的条件：
A. 系统中存在多个关键资源，且关键资源不可抢占。
B. 线程需要多个关键资源才能继续执行。
避免死锁：
A. 为每个使用的关键资源分配一个唯一的序列号。
B、为每个关键资源对应的线程锁分配相应的序号。
C. 系统中的每个线程都按严格递增的顺序请求关键资源。
、、、、提供了线程同步的手段。 使用线程的主要思想是它们可以尽可能并发执行，而无需在某些关键点在线程之间停止或等待。 例如，如果两个线程尝试同时访问同一个全局变量，结果可能不符合预期。
互斥量
提供互斥锁或互斥锁。 一次最多有一个线程拥有一个互斥体。 如果线程尝试访问已锁定的互斥锁，则该线程将休眠，直到拥有该互斥锁的线程解锁该互斥锁。 通常用于保护对共享数据的访问。 类的所有成员函数都是线程安全的。
头文件声明：#include
互斥量声明：QMutex m_Mutex;
互斥量加锁：m_Mutex.lock();
互斥量解锁：m_Mutex.unlock();
如果您解锁一个未锁定的互斥体，结果是未知的。
示例场景：
继承类实现多线程
#ifndef MYTHREAD_H
#define MYTHREAD_H
#include
#include
class MyThread : public QThread
{
Q_OBJECT
public:
MyThread();
protected:
virtual void run();
private:
};
#endif // MYTHREAD_H
#include "mythread.h"
#include
extern int global_Val;
MyThread::MyThread()
{
qDebug()<<"mainThread::currentId:"<
void MyThread::run()
{
while (global_Val>0) {
qDebug()<<"threadId:"<< QThread::currentThreadId()<<" global_val:"<
}
qDebug()<<"Task finish";
}
#include
#include "mythread.h"
int global_Val = 10;
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
MyThread thread1,thread2;
thread1.start();
thread2.start();
return a.exec();
}
定义两个线程都可以访问的全局变量。 当两个线程同时访问它们时，就会发生资源争用，造成不可预测的情况
程序运行结果如下
mainThread::currentId: 0x222c
mainThread::currentId: 0x222c
threadId: 0x3df4 global_val: 10
threadId: 0x3df4 global_val: 8
threadId: 0x3df4 global_val: 7
threadId: 0x10b8 global_val: 9
threadId: 0x3df4 global_val: 6
threadId: 0x10b8 global_val: 5
threadId: 0x3df4 global_val: 4
threadId: 0x3df4 global_val: 2
threadId: 0x3df4 global_val: 1
threadId: 0x10b8 global_val: 3
Task finish
Task finish
可以看到数据很乱。 这是没有加锁的情况。 接下来，添加锁。
#include "mythread.h"
#include
extern int global_Val;
extern QMutex globlMutex; //锁一定是全局的
MyThread::MyThread()
{
qDebug()<<"mainThread::currentId:"<
void MyThread::run()
{
while (global_Val>0) {
globlMutex.lock();
qDebug()<<"threadId:"<< QThread::currentThreadId()<<" global_val:"<
globlMutex.unlock();
}
qDebug()<<"Task finish";
}
互斥锁定和解锁必须在同一线程中成对发生。
运行后不会出现资源抢占、数据丢失等问题。
mainThread::currentId: 0x3b28
mainThread::currentId: 0x3b28
threadId: 0x1ae8 global_val: 10
threadId: 0x1024 global_val: 9
threadId: 0x1ae8 global_val: 8
threadId: 0x1024 global_val: 7
threadId: 0x1ae8 global_val: 6
threadId: 0x1024 global_val: 5
threadId: 0x1ae8 global_val: 4
threadId: 0x1024 global_val: 3
threadId: 0x1ae8 global_val: 2
threadId: 0x1024 global_val: 1
Task finish
threadId: 0x1ae8 global_val: 0
Task finish
如果觉得10太小，可以改为100。如果不加锁，数据丢失会更严重。
互斥锁
在比较复杂的函数和异常处理中，对类互斥对象执行lock()和()操作会非常复杂。 入口点需要Lock()，所有出口点都需要()。 它很容易出现在某些出口点。 () 没有被调用，因此 Qt 引入了辅助类来避免 lock() 和 () 操作。 在函数需要的地方创建一个对象，并将互斥指针传递给该对象。 此时，互斥体已经被锁定。 退出函数后，对象的局部变量会自行销毁，互斥锁被解锁。
头文件声明： #include
互斥锁声明： QMutexLocker mutexLocker(&m_Mutex);
互斥锁加锁： 从声明处开始（在构造函数中加锁）
互斥锁解锁： 出了作用域自动解锁（在析构函数中解锁）
使用互斥锁来同步线程
#include "mythread.h"
#include
extern int global_Val;
extern QMutex globlMutex; //锁一定是全局的
MyThread::MyThread()
{
qDebug()<<"mainThread::currentId:"<
void MyThread::run()
{
while (global_Val>0) {
QMutexLocker locker(&globlMutex);
qDebug()<<"threadId:"<< QThread::currentThreadId()<<" global_val:"<
}
qDebug()<<"Task finish";
}
条件变量
在Qt中称为等待条件，在Linux中称为条件变量。 我称它们为条件变量。
允许线程在发生某些情况时唤醒其他线程。 一个或多个线程可以阻塞等待并用 () 或 () 设置条件。 () 随机唤醒一个，() 唤醒全部。
QWaitCondition ()
bool wait ( QMutex * mutex, unsigned long time = ULONG_MAX )
bool wait ( QReadWriteLock * readWriteLock, unsigned long time = ULONG_MAX )
void wakeOne ()
void wakeAll ()
头文件声明： #include
等待条件声明： QWaitCondtion m_WaitCondition;
等待条件等待： m_WaitConditon.wait(&m_muxtex, time);
等待条件唤醒： m_WaitCondition.wakeAll();
在经典的生产者-消费者场景中，生产者首先必须检查缓冲区是否已满，如果缓冲区已满，则线程停止并等待条件。 如果未满，则在缓冲区中产生数据并激活条件。 使用互斥体来保护访问。 ::wait() 接收一个互斥锁作为参数，并且该互斥锁被调用线程初始化为锁定状态。 互斥体在线程进入睡眠状态之前解锁。 当线程被唤醒时，互斥体将处于锁定状态，从锁定状态到等待状态的转变是一个原子操作。 当程序开始运行时，只有生产者可以工作，消费者则被阻塞等待条件。 一旦生产者将一个字节放入缓冲区，就会触发条件并唤醒消费者线程。
生产者和消费者示例：
#include
#include
#include
#include
#include
#define BUFFER_SIZE 2
/*生产者*/
class producons
{
public:
int buffer[BUFFER_SIZE]; /*数据*/
QMutex lock; //互斥锁
int readpos,writepos; //读写位置
QWaitCondition nottempty; //条件变量 没有空间
QWaitCondition notfull; //条件变量 没有货物
producons()
{
readpos = writepos = 0;
}
};
producons buffer; //生产者对象
class Producor:public QThread
{
public:
void run();
void put(producons * prod,int data);
};
void Producor::run()
{
int n;
for(n = 0;n<5;n++)
{
qDebug()<<"生产者睡眠 1s...";
sleep(1);
qDebug()<<"生产信息:" << n;
put(&buffer, n);
}
for(n=5; n<10; n++)
{
qDebug()<<"生产者睡眠 3s...";
sleep(3);
qDebug()<<"生产信息："<< n;
put(&buffer,n);
}
put(&buffer, -1);
qDebug()<<"结束生产者!\n";
return;
}
void Producor::put(producons *prod, int data)
{
prod->lock.lock();
//write until buffer not full
while((prod->writepos + 1)%BUFFER_SIZE == prod->readpos)
{
qDebug()<<"生产者等待生产，直到buffer有空位置";
prod->notfull.wait(&prod->lock);
}
//将数据写入到buffer里面去
prod->buffer[prod->writepos] = data;
prod->writepos++;
if(prod->writepos >= BUFFER_SIZE)
prod->writepos = 0;
//仓库已满，等待消费者消费
prod->nottempty.wakeAll();
prod->lock.unlock();
}
class Consumer:public QThread
{
public:
void run();
int get(producons *prod);
};
void Consumer::run()
{
int d = 0;
while(1)
{
qDebug()<<"消费者睡眠 2s...";
sleep(2);
d = get(&buffer);
qDebug()<<"读取信息:"<< d;
if(d == -1) break;
}
qDebug()<<"结束消费者!";
return;
}
int Consumer::get(producons *prod)
{
int data;
prod->lock.lock(); //加锁
while(prod->writepos == prod->readpos)
{
qDebug()<<"消费者等待，直到buffer有消息\n";
prod->nottempty.wait(&prod->lock);
}
//读取buffer里面的消息
data = prod->buffer[prod->readpos];
prod->readpos++;
if(prod->readpos >=BUFFER_SIZE)
prod->readpos = 0;
//触发非满条件变量 告诉生产者可以生产
prod->notfull.wakeAll();
prod->lock.unlock();
return data;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Producor productor;
Consumer consumer;
productor.start();
consumer.start();
productor.wait();
consumer.wait();
return a.exec();
}
生产者睡眠 1s...
消费者睡眠 2s...
生产信息: 0
生产者睡眠 1s...
读取信息: 0
生产信息: 1
消费者睡眠 2s...
生产者睡眠 1s...
生产信息: 2
生产者等待生产，直到buffer有空位置
读取信息: 1
生产者睡眠 1s...
消费者睡眠 2s...
生产信息: 3
生产者等待生产，直到buffer有空位置
读取信息: 2
生产者睡眠 1s...
消费者睡眠 2s...
生产信息: 4
生产者等待生产，直到buffer有空位置
读取信息: 3
生产者睡眠 3s...
消费者睡眠 2s...
读取信息: 4
消费者睡眠 2s...
生产信息： 5
生产者睡眠 3s...
读取信息: 5
消费者睡眠 2s...
生产信息： 6
消费者等待，直到buffer有消息
生产者睡眠 3s...
读取信息: 6
消费者睡眠 2s...
消费者等待，直到buffer有消息
生产信息： 7
生产者睡眠 3s...
读取信息: 7
消费者睡眠 2s...
消费者等待，直到buffer有消息
生产信息： 8
生产者睡眠 3s...
读取信息: 8
消费者睡眠 2s...
消费者等待，直到buffer有消息
生产信息： 9
生产者等待生产，直到buffer有空位置
读取信息: 9
消费者睡眠 2s...
结束生产者!
读写锁
与 类似，但读写操作的处理方式不同。 可以允许多个读取器同时读取数据，但只能有一个写入，并且写入和读取操作不能同时进行。 使用代替可以使多线程程序并发性更高。默认模式是
类成员函数如下：
QReadWriteLock ( )
QReadWriteLock ( RecursionMode recursionMode )
void lockForRead ()
void lockForWrite ()
bool tryLockForRead ()
bool tryLockForRead ( int timeout )
bool tryLockForWrite ()
bool tryLockForWrite ( int timeout )
boid unlock ()
使用示例：
QReadWriteLock lock;
void ReaderThread::run()
{
lock.lockForRead();
read_file();
lock.unlock();
}
void WriterThread::run()
{
lock.lockForWrite();
write_file();
lock.unlock();
}
和
在比较复杂的函数和异常处理中对类似锁的对象进行()/()和()操作会非常复杂。 入口点需要 ()/()，所有出口点都需要 ()。 很容易出现在某些退出点没有调用()的情况，因此Qt引入了 和 类来简化解锁操作。 在函数需要的地方创建一个 OR 对象，并将锁指针传递给 OR 对象。 这时候锁已经被锁住了。 退出函数后，OR对象的局部变量会自行销毁，锁也会被解锁。
QReadWriteLock lock;
QByteArray readData()
{
QReadLocker locker(&lock);
...
return data;
}
信号
是的，这是一个概括。 它是一种特殊的线程锁，允许多个线程同时访问关键资源，而一个线程只能保护一个关键资源。 该类的所有成员函数都是线程安全的。
类成员函数：
QSemaphore ( int n = 0 )
void acquire ( int n = 1 )
int available () const
void release ( int n = 1 )
bool tryAcquire ( int n = 1 )
bool tryAcquire ( int n, int timeout )
伪代码：
const int BufferSize = 8192;
QSemaphore production(BufferSize);
QSemaphore consumption;
production.acquire();
//对BufferSize锁着后操作
consumption.release();
欢迎一起讨论C++开发
请扫描下方二维码添加田老师为微信好友
欢迎关注“跟田老师学C++”微信公众号
微信扫一扫打赏
支付宝扫一扫打赏
