1. Mutex.h——互斥量

Mutex.h

互斥量，每个需要共享的资源类，都持有一个

MutexLock

封装

muduo使用MutexLock类封装互斥量，同时该类的实例不能被复制。(如果同时解锁两次，也就是对一个为加锁的互斥量解锁，不会报错，正常)。
封装的好处:加强锁的功能，记录下锁所在的线程、能够打印死锁信息、以后还可以跨平台。
Mutex.h中类的成员函数都是内联的。

构造函数

MutexLock() _mutex

该类在创建的时候初始化_mutex，在析构的时候销毁_mutex。

析构函数

~MutexLock()

类在析构的时候会判断_holder是否为0,为0是才能析构，否则报错。

加锁解锁

lock()、unlock()

_mutex的初始化销毁、加锁解锁，被封装在宏中，以便在和出错的时候可以打印错文件名和代码行（因为内联在引用的代码中了）。
宏还看不懂。所以在这里忽略宏，直接使用两个加锁解锁函数。

记录下锁在线程

assignHolder()、unassignHolder()、_holder、isLockByThisThread()

在加锁以后记录下锁所在的线程ID，而在解锁以后置零。
还有一个函数判断当前线程是否和锁所在的线程相同。防止死锁。
同时如果，当前线程拥有此锁，那么应该报错。否则，如果判断拥有此锁，同时该cpu去执行别的线程了，就不能保护数据了。
但是muduo代码中没有显式调用该函数。如果刚解锁完，cpu就调到别的线程，还没有重置——holder那么也是错误的。
因为会在别的地方使用。但是属于线程的一部分，所以也定义在这里。

#include 
class MuteLock
{
private:
  pthread_mutex_t _mutex;
  pid_t _holder;
public:
  MutexLock()
  {
    pthread_mutex_init(&_mutex);
  }
  ~MutexLock()
  {
    assert(_holder==0);
    pthread_mutex_destroy(&_mutex);
  }
  void look()
  {
    pthread_mutex_lock(&_mutex);
    assignHolder();
  }
  void unlock()
  {
    pthread_mutex_unlock(&_mutex);
    unassignHolder();
  }
  //这个函数不明白，在那里用过
  void isLockByThisThread()
  {
    if(_holder==CurrentThread::tid())
    {
      std::abort;
    }
  }
  void assignHolder()
  {
    _holder=CurrentThread::tid();
  }
  void unassignHolder()
  {
    _holder=0;
  }
  MutexLock *getLock()
  {
    return &_mutex;
  }
}

上面的代码封装了互斥量。
不明白的地方就算。isLockByThread()的应用。源代码中没有显式的调用。
同时还有一个类中类MutexGuard。没有用过。

mutexLockGuard

执行实际的加锁解锁

该类需要MutexLock的指针类型来初始化，初始化的同时直接加锁。出函数作用域的时候，析构该对象，直接解锁

class MutexLockGuard
{
private:
  MutexLock *_mutex
public:
  MutexLockGuard(MutexLock &mutex):_mutex(mutex)
  {
    _mutex.lock();
  };
  ~MutexLockGuard()
  {
    _mutex.unlock();
  }
}

函数体第一句就是初始化该类实例。并不需要显式的加锁解锁。

析构的时候，mutexLockGuard先析构，然后解锁。然后MutexLock析构。