关于linux锁的c++封装 条件锁，读写锁（不同方式实现读写优先）

封装linux的pthread_mutex_t作为普通锁，pthread_cond_t和pthread_mutex_t一起作为条件锁，能够等待和发送唤醒信号。最后结合二者分别实现了读写锁。两个普通的锁组合成写优先的读写锁，一个条件锁封装为读优先的锁

</pre><pre name="code" class="cpp">//
// Created by ma on 2015/5/29.
//

#ifndef LOCK_H_
#define LOCK_H_

#include <unistd.h>

//normal lock
class Lock {
public:
Lock();
virtual ~Lock();
void lock();
void unlock();
protected:
pthread_mutex_t  mutex_t;
};

//lock with condition
class Condition_Lock:public Lock{
public:
Condition_Lock();
virtual ~Condition_Lock();
int wait();
int wait_time(int sec); //wait seconds
void signal();
void broadcast();
private:
pthread_cond_t cond;
};

//read-write lock with reading first
class RW_Lock{
public:
RW_Lock();
~RW_Lock();
void rd_lock();
void rd_unlock();
void wt_lock();
void wt_unlock();
private:
int m_stat;
Condition_Lock c_lock;
};

//read-write lock with writing first
class RW_Lock_w
{
public:
RW_Lock_w();
void rd_lock();
void rd_unlock();
void wt_lock();
void wt_unlock();
private:
int rd_cnt;
Lock r_lock;
Lock w_lock;
};

#endif //LOCK_H_

//
// Created by ma on 2015/5/29.
//

#include <pthread.h>
#include <sys/time.h>
#include "Lock.h"

Lock::Lock() {
pthread_mutex_init(&mutex_t,NULL);
}

void Lock::lock() {
pthread_mutex_lock(&mutex_t);
}

void Lock::unlock() {
pthread_mutex_unlock(&mutex_t);
}

Lock::~Lock() {
pthread_mutex_destroy(&mutex_t);
}
//---------------------------------------------------
int Condition_Lock::wait() {
return pthread_cond_wait(&cond,&mutex_t);
}

Condition_Lock::Condition_Lock():Lock() {
pthread_cond_init(&cond,NULL);
}

Condition_Lock::~Condition_Lock() {
pthread_cond_destroy(&cond);
}

void Condition_Lock::broadcast() {
pthread_cond_broadcast(&cond);
}

void Condition_Lock::signal() {
pthread_cond_signal(&cond);
}

int Condition_Lock::wait_time(int sec) {
struct timespec tp;

struct timeval tv;
gettimeofday(&tv,NULL);
tp.tv_sec=tv.tv_sec+sec;
tp.tv_nsec=tv.tv_usec*1000;

return pthread_cond_timedwait(&cond,&mutex_t,&tp);
}

//-----------------------------------------------
RW_Lock::RW_Lock():m_stat(0){
}

RW_Lock::~RW_Lock() {

}

void RW_Lock::rd_lock() {
c_lock.lock();
while(m_stat<0)
c_lock.wait();

m_stat++;
c_lock.unlock();
}

void RW_Lock::rd_unlock() {
c_lock.lock();
m_stat--;
c_lock.signal();
c_lock.unlock();
}

void RW_Lock::wt_lock() {
c_lock.lock();
while(m_stat>0)
c_lock.wait();

m_stat=-1;
}

void RW_Lock::wt_unlock() {
m_stat= 0;
c_lock.broadcast();
c_lock.unlock();
}
//-------------------------------------
RW_Lock_w::RW_Lock_w() {
}

void RW_Lock_w::rd_lock() {
r_lock.lock();
if(++rd_cnt==1)
w_lock.lock();
r_lock.unlock();
}

void RW_Lock_w::rd_unlock() {
r_lock.lock();
if(--rd_cnt==0)
w_lock.unlock();
r_lock.unlock();
}

void RW_Lock_w::wt_lock() {
w_lock.lock();
}
void RW_Lock_w::wt_unlock() {
w_lock.unlock();
}