boost读写锁实现

死锁的模型
1，lock lock ，unlock unlock  
2，lock  <wbr> return unlock
3，A中lock 调用B而B中也lock，
4，注意lock的范围。

#include <boost/thread.hpp>  
#include <boost/thread/recursive_mutex.hpp>  
#include <boost/thread/mutex.hpp>  
#include <boost/shared_ptr.hpp>  
#include <boost/progress.hpp>  
#include <boost/interprocess/detail/atomic.hpp>  
#include <list>  
#include <string>  
#include <iostream>  
#include <algorithm>  
#include <ctime>  
#include <stdint.h>  
  
#define THREAD_COUNT 100  
typedef boost::mutex                   Uni_Mutex;  
typedef boost::shared_mutex            WR_Mutex;  
typedef boost::unique_lock<WR_Mutex>   writeLock;  
typedef boost::shared_lock<WR_Mutex>   readLock;  
  
typedef boost::recursive_mutex         Rcs_Mutex;  
typedef boost::unique_lock<Rcs_Mutex>  recuLock;  
  
class Queue  
{  
public:  
    Queue(){};  
    ~Queue(){};  
  
    void write(int value)  
    {  
        writeLock   lockWrite(m_rwMutex);  
        m_list.push_back(value);  
        std::cout<<"write! now size is "<<size()<<" Thread id is "<<boost::this_thread::get_id()<<std::endl;  
    }  
  
    int  read(int pos)  
    {  
        readLock  lockRead(m_rwMutex);  
  
        if(size()==0 || pos>=size())  
            return -1;  
  
        std::list<int>::iterator itr = m_list.begin();  
        std::advance(itr , pos);  
        int value = *itr;  
  
        std::cout<<"read! now size is "<<size()<<" Thread id is "<<boost::this_thread::get_id()<<std::endl;  
        return value;  
    }  
  
    void remove(int pos)  
    {  
        writeLock  lockWrite(m_rwMutex);  
        if(size()==0 || pos>=size())  
            return;  
  
        std::list<int>::iterator itr = m_list.begin();  
        std::advance(itr , pos);  
        m_list.erase(itr);  
  
        std::cout<<"remove! size is "<<size()<<" Thread id is "<<boost::this_thread::get_id()<<std::endl;  
    }  
  
    int  size()  
    {  
        recuLock lock(m_sizeMutex);  
        return m_list.size();  
    }  
  
private:  
    std::list<int>  m_list;  
    Rcs_Mutex       m_sizeMutex;  
    WR_Mutex        m_rwMutex;  
};  
  
Queue queue;  
volatile uint32_t   count = 0;  
  
typedef boost::shared_ptr<boost::thread> Thread;  
  
Thread  thread_array[THREAD_COUNT];  
  
void increase_count()  
{  
    boost::interprocess::detail::atomic_inc32(&count);  
}  
  
void  testdata()  
{  
    boost::this_thread::at_thread_exit(increase_count);  
    for(int i=0;i<10;i++)  
    {  
        queue.read(i);  
        if(i%4==0)  
            queue.write(i);  
        if(i%2==0)  
            queue.remove(i);  
    }  
  
    std::cout<<"Thread "<<boost::this_thread::get_id()<<" exit"<<std::endl;  
}  
  
int main(int argc , char* argv[])  
{  
    boost::progress_timer t;  
    for(int i=0;i<10;i++)  
        queue.write(i);  
  
    std::cout<<"-----------thread create-----------"<<std::endl;  
  
    for(int i=0;i<THREAD_COUNT;++i)  
    {  
        thread_array[i].reset(new boost::thread(testdata));  
    }  
  
    while(1)  
    {  
        if(count>=THREAD_COUNT)  
            return 0;  
    }  
}