多线程编程 -- MutexLock

互斥量Mutex

互斥量本质上是一把锁，在访问共享资源钱对互斥量进行加锁，访问完成之后释放互斥量的锁。
pthread_mutex_t , 使用之前，必须首先对初始化

对互斥量进行加锁，调用pthread_mutex_lock
如果互斥量已经上锁，则线程将阻塞知道互斥量被解锁

如果不希望被阻塞，它可以使用pthread_mutex_trylock 尝试对互斥量进行加锁。如果互斥量处于未锁住状态， 那么pthread_mutex_trylock 将锁住互斥量，不会出现阻塞并返回0， 否则pthread_mutex_trylock就会失败，不会锁住互斥量，而返回EBUSY 。
下面来实现一个cpp 版本的Mutex

首先写一个类NoCopy，字面意思就是让类不能复制，具体的就是不能通过构造函数和赋值函数来构造对象。要达到这个目的，只需要自定义类型从这个类派生即可。原理就是把拷贝构造函数和赋值函数屏蔽掉，叫编译器编译不过。

nocopy.h

#ifndef COMMON_BASE_NOCOPY_H_
#define COMMON_BASE_NOCOPY_H_

#ifndef NOCOPY_CLASS
#define NOCOPY_CLASS(Class) \
 private: \
  Class(const Class&) = delete; \
  Class& operator=(const Class&) = delete
#endif

namespace common {
class Uncopyable {
  // private by default
  NOCOPY_CLASS(Uncopyable);
 public:
  Uncopyable() {}
  ~Uncopyable() {}
};
}  // namespace common
typedef common::Uncopyable Uncopyable;
#endif  // COMMON_BASE_NOCOPY_H_

这里使用宏定义NOCOPY 把拷贝构造函数和赋值函数屏蔽掉。

下面是一个cpp 版本的Mutex
mutex.h

class MutexLock {
  NOCOPY_CLASS(MutexLock);
 public:
  MutexLock()
      :status_(true) {
    if (pthread_mutex_init(&lock_, 0) != 0) {
      status_ = false; // 初始化失败
    }
  }

  virtual ~MutexLock() {
    if (status_ == true) {
      pthread_mutex_destroy(&lock_);
    }
  }

  void Lock() {
    if (status_ == true) {
      pthread_mutex_lock(&lock_);
      //assert(IsLocked());
    }
  }

  int TryLock() {
    if (status_ == true) {
      return pthread_mutex_trylock(&lock_);
    }
    return -1;
  }

  void Unlock() {
    //assert(IsLocked());
    if (status_ == true) {
      pthread_mutex_unlock(&lock_);  
    }
}

  bool IsLocked() const {
    return lock_.__data.__lock > 0;  
  }

 private:
  pthread_mutex_t lock_;
  bool status_;
};

注意：
通过成员函数Lock()进行上锁， Unlock() 进行解锁。不过并不推荐实践中直接去调用成员函数，因为调用成员函数就意味着，必须记住在每个函数出口都要去调用unlock()，也包括异常的情况。这是十分蛋疼的一件事。推荐使用 C++标准的RAII 来实现一个lock_guard 模版类，这个类在构造的时候提供已锁的互斥量，并且在析构的时候进行解锁，从而保证了一个已锁的互斥量总是会被正确地解锁。

下面给出lock_guard 的模版类

template <typename LockType>
class LockGuard {
  NOCOPY_CLASS(LockGuard);
 public:
  LockGuard(LockType* lock): lock_(lock) {
    lock_->Lock();
  }
  ~LockGuard() {
    lock_->Unlock();
  }
 private:
  LockType* lock_;
};