一个简易读写锁

发点牢骚：csdn上实在找不到读并行写互斥的读写锁。。所以自己写了一个

class rw_mutex{

private:

    std::condition_variable __cond_v;

    std::atomic_int __r_threads;

    std::mutex __inner_lock;

    std::atomic_bool __w_thread;

public:

    rw_mutex():__r_threads(0),__w_thread(0){}

    void r_lock();

    void w_lock();

    void r_unlock();

    void w_unlock();

};

void rw_mutex::r_lock(){

    __r_threads.fetch_add(1,std::memory_order_acq_rel);

    std::mutex temp_mutex;

    std::unique_lock<std::mutex> ul(temp_mutex);

    __cond_v.wait(ul,[this]{return __w_thread.load(std::memory_order_acquire)==0;});

}

void rw_mutex::w_lock(){

    __inner_lock.lock();

    std::mutex temp_mutex;

    std::unique_lock<std::mutex> ul(temp_mutex);

    __cond_v.wait(ul,[this]{return __r_threads.load(std::memory_order_acquire)==0;});

    __w_thread.store(true,std::memory_order_release);

   

}

void rw_mutex::r_unlock(){

    __r_threads.fetch_add(-1,std::memory_order_acq_rel);

    __cond_v.notify_all();//防止通知错线程

}

void rw_mutex::w_unlock(){

    __w_thread.store(false,std::memory_order_release);

    std::atomic_thread_fence(std::memory_order_acq_rel);

    __cond_v.notify_all();

    __inner_lock.unlock();

}

主要有一下几点思路：

1、总体上：利用条件变量实现读写线程的互斥，利用互斥元实现写线程的互斥。读线程等待写线程结束；而写线程等待所有线程结束，以及等待获取写线程锁

2、细节上：读线程的条件变量等待的线程锁是空锁，保证读线程的并行；写线程等待的锁是类里的内置公共锁，保证写线程的互斥。利用原子操作保证指令顺序