读写锁实现例子

#include

#include

#include

#include

#include

#include

#include

using namespace std;

using boost::this_thread::sleep;

using boost::posix_time::milliseconds;

const int MAX_READLOCK= 10;// 读操作限制数const int READTHREAD_NUM= 15;// 读线程数

class CRWMutex:public boost::mutex

{

public:

// 读锁辅助类

class RLock

{

private:

CRWMutex*m_pMutex;

RLock(const RLock&);

RLock&operator=(const RLock&);

public:

RLock(CRWMutex&m):m_pMutex(&m)

{

m_pMutex->ReadLock();

}

~RLock()

{

m_pMutex->Unlock();

}

};

// 写锁辅助类

class WLock

{

private:

CRWMutex*m_pMutex;

WLock(const RLock&);

WLock&operator=(const RLock&);

public:

WLock(CRWMutex&m):m_pMutex(&m)

{

m_pMutex->WriteLock();

}

~WLock()

{

m_pMutex->Unlock();

}

};

private:

boost::condition_variable_any m_oCondR;

boost::condition_variable_any m_oCondW;

int m_iCntR;// 读操作总数量

int m_iCntRding;// 正在执行中的读操作数量

int m_iCntW;// 写操作总数量

int m_iMaxReadLock;// 读操作数量限制

CRWMutex(const CRWMutex&);

CRWMutex&operator=(const CRWMutex&);

private:

// 是否能够获取读锁

bool TestReadLock()

{

return!((m_iCntW> 0 // 写操作优先检查||m_iCntRding>=m_iMaxReadLock));// 读操作数量越限检查}

// 是否读取或写入中

bool IsActived()

{

return m_iCntRding+m_iCntW>= 2;

}

// 当前锁状态是否为写锁

bool IsWriteLock()

{

return m_iCntW> 0 &&m_iCntRding== 0;

}

bool TestWriteLockNodify()

{

return 0

}

bool TestReadLockNodify()

{

return 0 ==m_iCntW&&m_iCntRding!=m_iCntR;

}

public:

CRWMutex(int max_rd=MAX_READLOCK)

:m_iMaxReadLock(max_rd),m_iCntR(0),m_iCntRding(0),m_iCntW(0)

{

}

~CRWMutex()

{

}

void ReadLock()

{

boost::mutex::scoped_lock lock(*this);

m_iCntR++;

while(!TestReadLock())

{

// 等待读锁

m_oCondR.wait(lock);

}

m_iCntRding++;

time_t now=time(NULL);

printf("r_lock[thread_0x%x] r=%d ring=%d w=%d\tOK\n",

&boost::this_thread::get_id(),m_iCntR,m_iCntRding,m_iCntW);

}

void WriteLock()

{

boost::mutex::scoped_lock lock(*this);

m_iCntW=m_iCntW> 0 ?m_iCntW+ 1 : 1;

time_t now=time(NULL);

while(IsActived())

{

// 等待写或读完成

printf("-w_lock wait r=%d ring=%d w=%d\n",m_iCntR,m_iCntRding,m_iCntW);

m_oCondW.wait(lock);

}

printf("-w_lock[thread_0x%x] get ok r=%d ring=%d w=%d\tOK\n",0,m_iCntR,m_iCntRding, m_iCntW);

}

void Unlock()

{

boost::mutex::scoped_lock lock(*this);

if(IsWriteLock())

{

m_iCntW--;

time_t now=time(NULL);

printf("-w_unlock[thread_0x%x] r=%d w=%d, so singal to rd_cnt\n",

&boost::this_thread::get_id(),m_iCntR,m_iCntW);

// 激活等待中的写或所有读操作

m_iCntW> 0 ?m_oCondW.notify_one():m_oCondR.notify_all();

}

else

{

m_iCntR--;

m_iCntRding--;

time_t now=time(NULL);

printf("r_unlock[thread_0x%x] r=%d ring=%d w=%d\n",

&boost::this_thread::get_id(),m_iCntR,m_iCntRding,m_iCntW);

// 锁状态通知

if(TestWriteLockNodify())

{

// 激活写操作

printf("r_unlock[thread_0x%x] rd_cnt=%d, so singal to wr_cnt[%d]\n",

&boost::this_thread::get_id(),m_iCntR,m_iCntW);

m_oCondW.notify_one();

}

else if(TestReadLockNodify())

{

//激活等待中的读操作

printf("r_unlock[thread_0x%x] rd_cnt=%d wr_cnt=0, so singal to

rding_cnt[%d]\n",

&boost::this_thread::get_id(),m_iCntR,m_iCntRding);

m_oCondR.notify_one();

}

}

}

// 线程安全队列

class CIntQueue

{

private:

boost::mutex m_oMutex;// 锁

vectorm_vecVals;

CIntQueue(const CIntQueue&);

CIntQueue&operator=(const CIntQueue&);

public:

CIntQueue(){}

~CIntQueue(){}

// 入队列

void PushBack(int iVal)throw()

{

boost::mutex::scoped_lock lock(m_oMutex);

m_vecVals.push_back(iVal);

}

// 出队列

int PopBack()throw()

{

boost::mutex::scoped_lock lock(m_oMutex);

int iRet= 0;

if(!m_vecVals.empty())

{

iRet=m_vecVals.back();

m_vecVals.pop_back();

}

return iRet;

}

};

static CRWMutex g_oMutexRW;

static boost::mutex g_oMutexWEnd;

static boost::condition_variable_any g_oCondWEnd; static CIntQueue g_oIntQueue;

static vectorg_vecInts;

static bool g_bThreadEnd=false;

void WriteThread()

const int TIMES_WAITTOINPUT= 30;// 写线程的退出提示static int val= 1;

while(1)

{

{

CRWMutex::WLock oLock(g_oMutexRW);// 获取写锁

val++;

g_oIntQueue.PushBack(val);

g_vecInts.push_back(val);

g_oCondWEnd.notify_one();// 激活一个读线程

sleep(milliseconds(10));

}

#ifdef_DEBUG

// 退出提示

if(val%TIMES_WAITTOINPUT== 0)

{

char line[255];

//printf( "\nExit(Y/N):\n" );

gets(line);

if('Y'==line[0]||'y'==line[0])

{

break;

}

}

#endif

}

{

boost::mutex::scoped_lock lock(g_oMutexWEnd);

g_bThreadEnd=true;

g_oCondWEnd.notify_all();// 激活并结束所有读线程}

return;

}

void ReadThread()

{

static int val= 1;// 读线程数

// 读线程退出条件

while(!g_bThreadEnd)

{

{

//wait for write_end nodify

boost::mutex::scoped_lock lock(g_oMutexWEnd);

g_oCondWEnd.wait(g_oMutexWEnd);

if(g_bThreadEnd)

{

// 退出

break;

}

printf("ReadThread_WakeUp=%d\n",val++);

}

{

CRWMutex::RLock oLock(g_oMutexRW);// 获取读锁

// 打印线程安全队列值

printf("====[thread_0x%x] Queue Value=%d\n",

&boost::this_thread::get_id(),g_oIntQueue.PopBack());

// 打印数组大小

printf("====[thread_0x%x] Vector Size=%d\n",

&boost::this_thread::get_id(),g_vecInts.size());

sleep(milliseconds(1000));

}

sleep(milliseconds(1000));

}

}

int main(int argc,char*argv[])

{

boost::thread thrdw(&WriteThread);

vector>thrdrs;

for(int i= 0;i

{

thrdrs.push_back(boost::shared_ptr(new boost::thread(&ReadThread)));

}

thrdw.join();

for(int i= 0;i

{

thrdrs[i]->join();

}

getchar();

return 0;

}

// 程序输出结果：

//-w_lock[thread_0x0] get ok r=0 ring=0 w=1 OK

//-w_unlock[thread_0x66fa24] r=0 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=0 ring=0 w=1 OK

//ReadThread_WakeUp=1

//-w_unlock[thread_0x66fa24] r=1 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=1 ring=0 w=1 OK

//ReadThread_WakeUp=2

//-w_unlock[thread_0x66fa24] r=2 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=2 ring=0 w=1 OK

//ReadThread_WakeUp=3

//-w_unlock[thread_0x66fa24] r=3 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=3 ring=0 w=1 OK

//ReadThread_WakeUp=4

//-w_unlock[thread_0x66fa24] r=4 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=4 ring=0 w=1 OK

//ReadThread_WakeUp=5

//-w_unlock[thread_0x66fa24] r=5 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=5 ring=0 w=1 OK

//ReadThread_WakeUp=6

//-w_unlock[thread_0x66fa24] r=6 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=6 ring=0 w=1 OK

//ReadThread_WakeUp=7

//-w_unlock[thread_0x66fa24] r=7 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=7 ring=0 w=1 OK

//ReadThread_WakeUp=8

//-w_unlock[thread_0x66fa24] r=8 w=0, so singal to rd_cnt //r_lock[thread_0xf6fb40] r=8 ring=1 w=0 OK

//====[thread_0xf6fd44] Queue Value=10

//r_lock[thread_0xe6fb40] r=8 ring=2 w=0 OK

//====[thread_0xf6fd50] Vector Size=9

//====[thread_0xe6fd44] Queue Value=9

//r_lock[thread_0x86fb40] r=8 ring=3 w=0 OK

//====[thread_0xe6fd50] Vector Size=9

//====[thread_0x86fd44] Queue Value=8

//r_lock[thread_0xc6fb40] r=8 ring=4 w=0 OK

//====[thread_0x86fd50] Vector Size=9

//====[thread_0xc6fd44] Queue Value=7

//r_lock[thread_0xa6fb40] r=8 ring=5 w=0 OK

//====[thread_0xc6fd50] Vector Size=9

//====[thread_0xa6fd44] Queue Value=6

//r_lock[thread_0x106fb40] r=8 ring=6 w=0 OK

//====[thread_0xa6fd50] Vector Size=9

//====[thread_0x106fd44] Queue Value=5

//r_lock[thread_0x146fb40] r=8 ring=7 w=0 OK

//====[thread_0x106fd50] Vector Size=9

//====[thread_0x146fd44] Queue Value=4

//r_lock[thread_0x126fb40] r=8 ring=8 w=0 OK

//====[thread_0x146fd50] Vector Size=9

//====[thread_0x126fd44] Queue Value=3

//-w_lock wait r=8 ring=8 w=1

//====[thread_0x126fd50] Vector Size=9

//r_unlock[thread_0xf6fb1c] r=7 ring=7 w=1

//r_unlock[thread_0xe6fb1c] r=6 ring=6 w=1

//r_unlock[thread_0xc6fb1c] r=5 ring=5 w=1

//r_unlock[thread_0xa6fb1c] r=4 ring=4 w=1

//r_unlock[thread_0x86fb1c] r=3 ring=3 w=1

//r_unlock[thread_0x106fb1c] r=2 ring=2 w=1

//r_unlock[thread_0x126fb1c] r=1 ring=1 w=1

//r_unlock[thread_0x146fb1c] r=0 ring=0 w=1

//r_unlock[thread_0x146fb28] rd_cnt=0, so singal to wr_cnt[1] //-w_lock[thread_0x0] get ok r=0 ring=0 w=1 OK

//ReadThread_WakeUp=9

//-w_unlock[thread_0x66fa24] r=1 w=0, so singal to rd_cnt

//-w_lock[thread_0x0] get ok r=1 ring=0 w=1 OK

//ReadThread_WakeUp=10

//-w_unlock[thread_0x66fa24] r=2 w=0, so singal to rd_cnt

//-w_lock[thread_0x0] get ok r=2 ring=0 w=1 OK

//ReadThread_WakeUp=11

//-w_unlock[thread_0x66fa24] r=3 w=0, so singal to rd_cnt

//-w_lock[thread_0x0] get ok r=3 ring=0 w=1 OK

//ReadThread_WakeUp=12

//-w_unlock[thread_0x66fa24] r=4 w=0, so singal to rd_cnt

//-w_lock[thread_0x0] get ok r=4 ring=0 w=1 OK

//ReadThread_WakeUp=13

//-w_unlock[thread_0x66fa24] r=5 w=0, so singal to rd_cnt

//-w_lock[thread_0x0] get ok r=5 ring=0 w=1 OK

//ReadThread_WakeUp=14

//-w_unlock[thread_0x66fa24] r=6 w=0, so singal to rd_cnt

//-w_lock[thread_0x0] get ok r=6 ring=0 w=1 OK

//ReadThread_WakeUp=15

//-w_unlock[thread_0x66fa24] r=7 w=0, so singal to rd_cnt

//-w_lock[thread_0x0] get ok r=7 ring=0 w=1 OK

//-w_unlock[thread_0x66fa24] r=7 w=0, so singal to rd_cnt

//-w_lock[thread_0x0] get ok r=7 ring=0 w=1 OK

//-w_unlock[thread_0x66fa24] r=7 w=0, so singal to rd_cnt

//-w_lock[thread_0x0] get ok r=7 ring=0 w=1 OK

//-w_unlock[thread_0x66fa24] r=7 w=0, so singal to rd_cnt

//-w_lock[thread_0x0] get ok r=7 ring=0 w=1 OK

//-w_unlock[thread_0x66fa24] r=7 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=7 ring=0 w=1 OK

//-w_unlock[thread_0x66fa24] r=7 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=7 ring=0 w=1 OK

//-w_unlock[thread_0x66fa24] r=7 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=7 ring=0 w=1 OK

//-w_unlock[thread_0x66fa24] r=7 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=7 ring=0 w=1 OK

//-w_unlock[thread_0x66fa24] r=7 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=7 ring=0 w=1 OK

//-w_unlock[thread_0x66fa24] r=7 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=7 ring=0 w=1 OK

//-w_unlock[thread_0x66fa24] r=7 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=7 ring=0 w=1 OK

//-w_unlock[thread_0x66fa24] r=7 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=7 ring=0 w=1 OK

//-w_unlock[thread_0x66fa24] r=7 w=0, so singal to rd_cnt //-w_lock[thread_0x0] get ok r=7 ring=0 w=1 OK

//-w_unlock[thread_0x66fa24] r=7 w=0, so singal to rd_cnt //r_lock[thread_0xd6fb40] r=7 ring=1 w=0 OK

//====[thread_0xd6fd44] Queue Value=30

//r_lock[thread_0x116fb40] r=7 ring=2 w=0 OK

//====[thread_0xd6fd50] Vector Size=29

//====[thread_0x116fd44] Queue Value=29

//r_lock[thread_0x76fb40] r=7 ring=3 w=0 OK

//====[thread_0x116fd50] Vector Size=29

//====[thread_0x76fd44] Queue Value=28

//r_lock[thread_0x96fb40] r=7 ring=4 w=0 OK

//====[thread_0x76fd50] Vector Size=29

//====[thread_0x96fd44] Queue Value=27

//r_lock[thread_0xb6fb40] r=7 ring=5 w=0 OK

//====[thread_0x96fd50] Vector Size=29

//r_lock[thread_0x156fb40] r=7 ring=6 w=0 OK

//====[thread_0xb6fd44] Queue Value=26

//====[thread_0x156fd44] Queue Value=25

//r_lock[thread_0x136fb40] r=7 ring=7 w=0 OK

//====[thread_0xb6fd50] Vector Size=29

//====[thread_0x156fd50] Vector Size=29

//====[thread_0x136fd44] Queue Value=24

//====[thread_0x136fd50] Vector Size=29

//r_unlock[thread_0xd6fb1c] r=6 ring=6 w=0

//r_unlock[thread_0x116fb1c] r=5 ring=5 w=0

//r_unlock[thread_0xb6fb1c] r=4 ring=4 w=0

//r_unlock[thread_0x156fb1c] r=3 ring=3 w=0 //r_unlock[thread_0x76fb1c] r=2 ring=2 w=0 //r_unlock[thread_0x96fb1c] r=1 ring=1 w=0 //r_unlock[thread_0x136fb1c] r=0 ring=0 w=0