用C++封装linux下的互斥锁MutexLock和条件变量Condition

/*封装互斥锁的时候&＃xff0c;要用到的方法&＃xff0c;20200605*/
//问题一&＃xff1a;MutexLock和Condition是否要设计成单例模式&＃xff1f;
// 单例模式只能通过该类创建出一个对象&＃xff0c;这意味着只能创建一把锁&＃xff0c;如果再来一把锁的话&＃xff0c;
// 这显然不符合需求&＃xff0c;锁可以有多把&＃xff0c;条件变量也可以有多个//问题二&＃xff1a;MutexLock和Condition的成员是否要设计成static?
// 不能设计成static,否则只能是唯一的//问题三&＃xff1a;MutexLock与Condition应该是什么关系&＃xff1f;
// 从互斥锁和条件变量的创建以及销毁来看&＃xff0c;彼此并不负责对方的生命周期&＃xff0c;互不相干&＃xff0c;彼此独立
// 由于Condition的接口wait方法是无参的&＃xff0c;但是接下来的操作中需要用到互斥锁&＃xff0c;MuteLock只能以指针的形式出现在Condition的数据成员中&＃xff0c;表达的是一种关联关系&＃xff08;A has B)//问题四&＃xff1a;成员变量引用&＃xff0c;需要注意构造函数初始化列表中进行// MutexLock 和Condition不能进行复制。class MutexLock
{//先定义接口&＃xff0c;再定义实现
public:MutexLock(); //构造函数初始化互斥锁~MutexLock(); //析构函数进行销毁互斥锁 pthread_mutex_destroy(pthread——mutex_t*);void lock(); //phtread_mutex_lockvoid unlock(); //pthread_mutex_unlockpthread_mutex_t *getMutexLockPtr(){ return &_mutex2; } //返回一个 操作锁private: //成员放什么//static pthread_mutex_t _mutex; pthread_mutex_t _mutex2;
};class Condition
{public://...Condition(); // 初始化pthread_cond_init(phtread_cond_t*,);~Condition(); // 销毁 pthread_cond_destroy(pthread_cond_t*);void wait(); // pthread_cond_wait//void wait(MutexLock &mutex);//传参的叫依赖关系--->不调用该函数&＃xff0c;彼此是无关的void notify(); // pthread_cond_signalvoid notifyall(); // pthread_cond_broadcastprivate://...//pthred_mutex_t * _mutex;//不能&＃xff0c;要使用已经封装好的MutexLock//pthread_mutex_t _mutex;//不能&＃xff0c;意味着条件变量的对象要负责互斥锁的销毁//MutexLock _mutex;//不能以对象成员的形式出现MutexLock & _mutex;//可以&＃xff0c;用引用(指针)都可以的//MutexLock * _mutex;//关联关系&＃xff08;A has B&＃xff0c;彼此并不负责对方生命周期)pthread_cond_t _cond;
};


怎么去设计一个合理的类&＃xff1f;面向对象设计 OOD,而不是面向过程
最难的是面向对象设计OOD&＃xff0c;学习C&＃43;&＃43;的语法知识是在做OOP
OOD难在对于一个需求或问题进行抽象&＃xff0c;分析&＃xff0c;为了应对需求的变化。int pthread_cond_destroy(pthread_cond_t *cond);分为上半部和下半部
使用条件变量的时候一定要调用互斥锁&＃xff0c;因为哟啊操作临界资源上半部&＃xff1a;当加锁之后&＃xff0c;调用该方法时&＃xff0c;表示当前线程A要进入阻塞状态&＃xff0c;但是在进入阻塞状态之前会解锁下半部&＃xff1a;当另外一个线程B调用pthread_cond_signal方法&＃xff0c;激活线程A的条件变量&＃xff0c;线程A要再往下执行&＃xff0c;必须哟啊执行加锁操作&＃xff0c;才能往后走&＃xff0c;接下来哟啊操作临界资源。
int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex&＃xff09;; //内核完成

代码如下&＃xff1a;

MutexLock.hpp   Condition.hpp Condition.cc Test.cc Test2.cc Test3.cc

MutexLock.hpp

#ifndef __WD_MUTEXLOCK_H__
#define __WD_MUTEXLOCK_H__#include
#include
using std::cout;
using std::endl;namespace wd
{class MutexLock
{
public:MutexLock(): _isLocking(false){if(0!&＃61;pthread_mutex_init(&_mutex,NULL)){perror("pthread_mutex_init");}}//禁止复制控制MutexLock(const MutexLock &)&＃61;delete;MutexLock & operator&＃61;(const MutexLock &)&＃61;delete;~MutexLock() {if(0!&＃61;pthread_mutex_destroy(&_mutex)){perror("pthread_mutex_destroy");}}void lock(){if(0!&＃61;pthread_mutex_lock(&_mutex)){perror("pthread_mutex_lock");return ;}_isLocking&＃61;true;}void unlock(){if(0!&＃61;pthread_mutex_unlock(&_mutex)){perror("pthread_mutex_unlock");return ;}_isLocking&＃61;false;}pthread_mutex_t *getMutexLockPtr(){//??????return &_mutex;}bool isLocking() const {return _isLocking;}private:pthread_mutex_t _mutex;bool _isLocking;
};class MutexLockGuard
{
public:explicitMutexLockGuard(MutexLock &mutex): _mutex(mutex)//构造函数加锁{_mutex.lock();}~MutexLockGuard()//析构函数来解锁{_mutex.unlock();}private://获取一个互斥锁的对象MutexLock &_mutex;
};}//end of namespace wd#endif

Condition.hpp

#ifndef __WD_CONDITION_H__
#define __WD_CONDITION_H__
#include "MutexLock.hpp"
#include
#include using std::cout;
using std::endl;namespace wd
{class Condition
{
public:explicitCondition(MutexLock & mutex);~Condition(); //禁止复制&＃xff1f;Condition(const Condition &)&＃61;delete;Condition &operator&＃61;(const Condition &)&＃61;delete;void wait();void notify();void notifyAll();private:pthread_cond_t _cond;MutexLock & _mutex;
};}
#endif

Condition.cc


#include "Condition.hpp"
#include using std::cout;
using std::endl;namespace wd
{
Condition::Condition(MutexLock & mutex)
: _mutex(mutex)
{if(0!&＃61;pthread_cond_init(&_cond,NULL)){perror("pthread_cond_init");}
}Condition:: ~Condition()
{if(0!&＃61;pthread_cond_destroy(&_cond)){perror("pthread_cond_destroy");}
}void Condition::wait()
{if(0!&＃61;pthread_cond_wait(&_cond,_mutex.getMutexLockPtr())){perror("pthread_cond_wait");}
}
void Condition::notify()
{if(0!&＃61;pthread_cond_signal(&_cond)){perror("pthread_cond_signal");}
}void Condition::notifyAll()
{if(0!&＃61;pthread_cond_broadcast(&_cond)){perror("pthread_cond_broadcast");}
}}//end of namespace wd


Test1.cc

两个线程抢占式卖票

/* autor:liulei */
/* C&＃43;&＃43; */
#include "Condition.hpp"
#include using std::cout;
using std::endl;struct CriticalResource
{//构造函数完成对象的初始化CriticalResource(long tickets): _tickets(tickets), _mutex(), _cond(_mutex){}long _tickets&＃61;1000;wd::MutexLock _mutex;wd::Condition _cond;
};/*1号窗口和2号窗口抢占式的方式卖票*/void *windowsSale1(void *arg)
{cout<<">> windows1: "<(arg);while(1){presource->_mutex.lock();if(presource->_tickets>0){presource->_tickets--;cout<<"windows1 left:tickets "<_tickets<_mutex.unlock();break;//票卖完的时候&＃xff0c;需要退出线程}presource->_mutex.unlock();}return nullptr;
}void *windowsSale2(void *arg)
{cout<<">> windows2: "<(arg);while(1){presource->_mutex.lock();if(presource->_tickets>0){presource->_tickets--;cout<<"windows2 left:tickets "<_tickets<_mutex.unlock();break;//票卖完的时候&＃xff0c;需要退出线程}presource->_mutex.unlock();}return nullptr;
}void test()
{CriticalResource resoure(100000);pthread_t pthid1,pthid2;pthread_create(&pthid1,nullptr,windowsSale1,(void*)&resoure);pthread_create(&pthid2,nullptr,windowsSale2,(void*)&resoure);cout<<"> main thread:"<}int main()
{ test();return 0;
}

Test2.cc

两个线程交替卖票

/* autor:liulei */
/* C&＃43;&＃43; */
#include "Condition.hpp"
#include using std::cout;
using std::endl;struct CriticalResource
{CriticalResource()&＃61;default;//构造函数完成对象的初始化CriticalResource(long tickets): _tickets(tickets), _mutex(), _cond(_mutex){}long _tickets&＃61;1000;bool _flag&＃61;false;wd::MutexLock _mutex;wd::Condition _cond{_mutex};
};/*1号窗口和2号窗口交替卖票*/
//1号卖完了通知2号卖&＃xff0c;2号卖完了通知1号卖
// _flag&＃61;true,一号卖&＃xff0c;否则一号等待
// _flag&＃61;flase,二号卖&＃xff0c;否则二号等待
void *windowsSale1(void *arg)
{cout<<">> windows1: "<(arg);while(1){presource->_mutex.lock();if(presource->_flag&＃61;&＃61;false){presource->_cond.wait();//等待&＃xff0c;阻塞}//_flag&＃61;true&＃xff0c;一号卖票if(presource->_tickets>0){presource->_tickets--;cout<<"windows1 left:tickets "<_tickets<_mutex.unlock();//通知2号窗口卖票&＃xff0c;所以要修改条件presource->_flag&＃61;false;presource->_cond.notify();}else{cout<<"Windows1:tickets has sold out!"<_mutex.unlock();break;//票卖完的时候&＃xff0c;需要退出线程}}return nullptr;
}void *windowsSale2(void *arg)
{cout<<">> windows2: "<(arg);while(1){presource->_mutex.lock();if(presource->_flag&＃61;&＃61;true){presource->_cond.wait();}//2.2 _flag 为false的时候&＃xff0c;执行卖票操作 if(presource->_tickets>0){presource->_tickets--;cout<<"windows2 left:tickets "<_tickets<_mutex.unlock();presource->_flag&＃61;true;presource->_cond.notify();}else{cout<<"Windows2:tickets has sold out!"<_mutex.unlock();break;//票卖完的时候&＃xff0c;需要退出线程}}return nullptr;
}void test()
{CriticalResource resoure(100000);pthread_t pthid1,pthid2;pthread_create(&pthid1,nullptr,windowsSale1,(void*)&resoure);pthread_create(&pthid2,nullptr,windowsSale2,(void*)&resoure);cout<<"> main thread:"<}int main()
{ test();return 0;
}


Test3.cc

两个线程卖票&＃xff0c;可以用C&＃43;&＃43;去解决解锁之前出现的死锁问题

/* autor:liulei */
/* C&＃43;&＃43; */
#include "Condition.hpp"
#include using std::cout;
using std::endl;struct CriticalResource
{CriticalResource()&＃61;default;//构造函数完成对象的初始化CriticalResource(long tickets): _tickets(tickets), _mutex(), _cond(_mutex){}long _tickets&＃61;1000;bool _flag&＃61;false;wd::MutexLock _mutex;wd::Condition _cond{_mutex};
};/*1号窗口和2号窗口交替卖票*/
//1号卖完了通知2号卖&＃xff0c;2号卖完了通知1号卖
// _flag&＃61;true,一号卖&＃xff0c;否则一号等待
// _flag&＃61;flase,二号卖&＃xff0c;否则二号等待
void *windowsSale1(void *arg)
{cout<<">>>> windows1: "<(arg);while(1){/* presource->_mutex.lock(); */wd::MutexLockGuard mlg(presource->_mutex);if(presource->_flag&＃61;&＃61;false){presource->_cond.wait();//等待&＃xff0c;阻塞}//_flag&＃61;true&＃xff0c;一号卖票if(presource->_tickets>0){presource->_tickets--;cout<<"windows1 left:tickets "<_tickets<_mutex.unlock(); *///通知2号窗口卖票&＃xff0c;所以要修改条件presource->_flag&＃61;false;presource->_cond.notify();}else{cout<<"Windows1:tickets has sold out!"<_mutex.unlock(); */break;//票卖完的时候&＃xff0c;需要退出线程}}return nullptr;
}void *windowsSale2(void *arg)
{cout<<"windows2: "<(arg);while(1){/* presource->_mutex.lock(); */wd::MutexLockGuard mlg(presource->_mutex);if(presource->_flag&＃61;&＃61;true){presource->_cond.wait();}//2.2 _flag 为false的时候&＃xff0c;执行卖票操作 if(presource->_tickets>0){presource->_tickets--;cout<<"windows2 left:tickets "<_tickets<_flag&＃61;true;presource->_cond.notify();}else{cout<<"Windows2:tickets has sold out!"<_mutex.unlock(); */break;//票卖完的时候&＃xff0c;需要退出线程}}return nullptr;
}void test()
{CriticalResource resoure(100000);pthread_t pthid1,pthid2;pthread_create(&pthid1,nullptr,windowsSale1,(void*)&resoure);pthread_create(&pthid2,nullptr,windowsSale2,(void*)&resoure);cout<<"> main thread:"<}int main()
{ test();return 0;
}