C++读写锁-实现优先写

// 读写互斥量
// 当有写和读操作同时竞争时，写操作优先与读操作
class CRWMutex
{
public:
	CRWMutex()
		: m_read_count_(0)
		, m_write_count_(0)
		, m_is_writing_(false)
	{
	}

	virtual ~CRWMutex() = default;

	void LockRead()
	{
		std::unique_lock<std::mutex> locker(m_mutex_);
		m_read_cond_.wait(locker, [=]{return 0 == m_write_count_; }); // 没有写等待时，可执行读
		++m_read_count_;
	}

	void UnLockRead()
	{
		std::unique_lock<std::mutex> locker(m_mutex_);
		if (0 == --m_read_count_ && 0 != m_write_count_) // 当读操作减为0，并且有等待的写操作时，通知一个线程写
		{
			m_write_cond.notify_one();
		}
	}

	void LockWrite()
	{
		std::unique_lock<std::mutex> locker(m_mutex_);
		++m_write_count_;																//写先进行计数统计，这里可以实现写优先于读
		m_write_cond.wait(locker, [=]{return 0 == m_read_count_ && !m_is_writing_; });	// 没有读操作并且没有正在写时，可执行写
		m_is_writing_ = true;
	}

	void UnLockWrite()
	{
		std::unique_lock<std::mutex> locker(m_mutex_);
		if (0 == --m_write_count_)
		{
			m_read_cond_.notify_all();		// 没有写操作等待时，通知所有读
		}else
		{
			m_write_cond.notify_one();		// 还有写操作等待时，通知一个线程写
		}
		m_is_writing_ = false;
	}

private:
	std::mutex m_mutex_;
	volatile int m_read_count_;				// 读操作持有者计数
	volatile int m_write_count_;			// 写操作持有者计数
	bool m_is_writing_;						// 是否正在写
	std::condition_variable m_read_cond_;	// 可读条件变量
	std::condition_variable m_write_cond;	// 可写条件变量
};