学习记录(4.3)---面向对象的条件变量类的封装

 上一篇文章我们介绍了MutexLock（互斥锁）类的封装，学习记录(4.2)---面向对象的互斥锁类的封装，接下来是条件变量类的封装

相关函数见：学习记录(4.1)-----面向对象生产者消费者封装

直接开始！！！！

1、类图

MutexLock类和Condition类属于关联关系，成员变量中有MutexLock类的引用

2，头文件Condition.h

#ifndef __CONDITION_H
#define __CONDITION_H
#include<pthread.h>
//#include"Mutex_lock.h"; 防止循环依赖

class MutexLock; // 前向声明
class Condition : Noncopyable
{
private:
    MutexLock &_mutex; // 互斥锁的引用
    pthread_cond_t _cond; // 条件变量
public:
    Condition(MutexLock &mutex); // 构造函数
    ~Condition(); // 析构函数
    void wait(); // 等待
    void notify(); // 唤醒一个
    void notifyAll(); // 唤醒所有
};

// Condition.h 文件中定义了 Condition 类，该类有一个互斥锁的引用和一个条件变量。
// 构造函数接受一个互斥锁的引用作为参数，用于初始化条件变量。
// wait() 函数用于等待条件变量，它首先会释放互斥锁，然后阻塞等待条件变量，当条件变量被唤醒时，它会重新获取互斥锁。
// notify() 函数用于唤醒一个等待条件变量的线程，它首先会释放互斥锁，然后唤醒一个等待条件变量的线程，最后重新获取互斥锁。
// notifyAll() 函数用于唤醒所有等待条件变量的线程，它首先会释放互斥锁，然后唤醒所有等待条件变量的线程，最后重新获取互斥锁。

#endif

 3、具体实现Condition.cc

#include"Condition.h"
#include<stdio.h>
#include"Mutex_lock.h"

//构造函数，传入一个互斥锁的引用
Condition::Condition(MutexLock &mutex)
:_mutex(mutex)
{
    //初始化条件变量
    int ret = pthread_cond_init(&_cond, nullptr);
    if(ret)
    {
        perror("pthread_cond_init error");
        return;
    }
}

//析构函数，销毁条件变量
Condition::~Condition()
{
    //销毁条件变量
    int ret = pthread_cond_destroy(&_cond);
    if(ret)
    {
        perror("pthread_cond_destroy error");
        return;
    }
}

//等待条件变量
void Condition::wait()
{
    //等待条件变量，同时会释放互斥锁
    int ret = pthread_cond_wait(&_cond, _mutex.getMutexLockPtr());
    if(ret)
    {
        perror("pthread_cond_wait error");
        return;
    }
}

//唤醒一个等待条件变量的线程
void Condition::notify()
{
    //唤醒一个等待条件变量的线程
    int ret = pthread_cond_signal(&_cond);
    if(ret)
    {
        perror("pthread_cond_signal error");
        return;
    }
}

//唤醒所有等待条件变量的线程
void Condition::notifyAll()
{
    //唤醒所有等待条件变量的线程
    int ret = pthread_cond_broadcast(&_cond);
    if(ret)
    {
        perror("pthread_cond_broadcast error");
        return;
    }
}