多线程编程 RW_LOCK 读写锁

RW锁 读写锁，也叫共享独占锁
互斥量 要么是锁住状态，要么是不加锁状态，而且一次只有一个线程可以对其加锁。

读写锁可以有三种状态，读模式下加锁状态，写模式下加锁状态，不加锁状态。一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁。

和互斥量一样，读写锁在使用之前必须初始化，在释放他们底层的内存前必须销毁。

要在读模式下锁定读写锁，需要调用pthread_rwlock_rdlock;
要在写模式下锁定读写锁，需要调用pthread_rwlock_wrlock;
不管以何种方式锁住读写锁，都可以调用pthread_rwlock_unlock 进行解锁。

在读操作远远高于写操作的时候，使用读写锁才可能改善性能。

下面给出一个cpp 版本的 rw_lock

Rwlock.h

class RwLock {
  NOCOPY_CLASS(RwLock);
 public:
  RwLock();
  virtual ~RwLock();

  void ReadLock();
  void WriteLock();

  void Unlock();
  void ReadUnlock();
  void WriteUnlock();

  bool IsReadLocked();
  bool IsWriteLocked();
 private:
  pthread_rwlock_t lock_;
};

Rw_lock.cc

RwLock::RwLock() {
  pthread_rwlock_init(&lock_, 0);
}

RwLock::~RwLock() {
  pthread_rwlock_destroy(&lock_);
}

void RwLock::ReadLock() {
  pthread_rwlock_rdlock(&lock_);
}

void RwLock::WriteLock() {
  pthread_rwlock_wrlock(&lock_);
}

void RwLock::Unlock() {
  assert(IsReadLocked() || IsWriteLocked());
  pthread_rwlock_unlock(&lock_);
}

void RwLock::ReadUnlock() {
  assert(IsReadLocked());
  pthread_rwlock_unlock(&lock_);
}

void RwLock::WriteUnlock() {
  assert(IsWriteLocked());
  pthread_rwlock_unlock(&lock_);
}

bool RwLock::IsReadLocked() {
    return lock_.__data.__nr_readers != 0;
}

bool RwLock::IsWriteLocked() {
  return lock_.__data.__writer != 0;
}

同样，不建议直接使用成员函数来上锁，需要写一个ReadLockGuard模版来更好的使用锁，防止出错。

template <typename LockTye>
class ReadLockGuard {
  NOCOPY_CLASS(ReadLockGuard);
 public:
  ReadLockGuard(LockType * lock):lock_(lock) {
    lock->ReadLock();
  }
  ~ReadLockGuard() {
     lock_->ReadUnlock();
  }
  private:
    LockType* lock_;
};

template <typename LockType>
class WriteLockGuard {
  NOCOPY_CLASS(WriteLockGuard);
 public:
  WriteLockGuard(LockType* lock): lock_(lock) {
    lock_->WriteLock();
  }
  ~WriteLockGuard() {
    lock_->WriteUnlock();
  }
 private:
  LockType* lock_;
};