前言：
对于muduo库，我觉得，光Linux多线程上提到的一些实现，还是不够的，在base/里面，还有/net里面提供了很多不错的实现，值得去学习，暑假算是看看muduo的百分之八十的源码，并对其进行了一次实现，（剩下的在最近总结的时候，也会开始看看，并实现一遍），对于muduo库，简单谈谈自己对其实现的理解。
用RAII管理你的锁
Posix Thread内定义的一系列的mutex函数，但是是基于C语言的，用起来很不方便，需要不断地初始化，销毁p，我们要对其进行一定程度的封装，使得我们不必重复的写初始话，销毁操作，专注在使用上。
muduo对锁进行了封装，分别是Mutex、MutexGruad、Condition、CountDownLatch。
Mutex的实现
class MutexLock : boost::noncopyable { public: MutexLock():holder_(0) { MCHECK(pthread_mutex_init(&mutex_, NULL)); } ~MutexLock() { assert(holder_ == 0); MCHECK(pthread_mutex_destroy(&mutex_)); } bool isLocketByThisThread() const { return holder_ == CurrentThread::tid(); } void assertLocked() const { assert(isLocketByThisThread()); } void lock() { MCHECK(pthread_mutex_lock(&mutex_)); assignHolder(); } void unlock() { unassignHolder(); MCHECK(pthread_mutex_unlock(&mutex_)); } pthread_mutex_t* getPthreadMutex() /* non-const */ { return &mutex_; } private: void unassignHolder() { holder_ = 0; } void assignHolder() { holder_ = CurrentThread::tid(); } private: pthread_mutex_t mutex_; pid_t holder_; // 如果不是同一个线程的加锁和解锁则会失败 };如果单单只是这样实现mutex，还是太过于麻烦，而且这个锁，我们只能在函数内自动获取自动产生，然后自动析构，会有一定的性能损失。
下面实现了MutexLockGurad用于自动获取锁，加锁和解锁。
class MutexLockGuard : boost::noncopyable { public: explicit MutexLockGuard(MutexLock& mutex):mutex_(mutex) { mutex_.lock(); } ~MutexLockGuard() { mutex_.unlock(); } private: MutexLock& mutex_; };还有需要注意的就是，在实现的时候，定义了两个宏
// 用宏的方式检查返回值是否为0， #ifdef CHECK_PTHREAD_RETURN_VALUE #ifdef NDEBUG __BEGIN_DECLS extern void __assert_perror_fail (int errnum, const char *file, unsigned int line, const char *function) __THROW __attribute__ ((__noreturn__)); __END_DECLS #endif #define MCHECK(ret) ({ __typeof__ (ret) errnum = (ret); \ if (__builtin_expect(errnum != 0, 0)) \ __assert_perror_fail (errnum, __FILE__, __LINE__, __func__);}) #else // CHECK_PTHREAD_RETURN_VALUE // 定义一个ret类型的errnum，然后判断errnum是否＝＝０， // (void)(value)作用仅仅就是以显眼的方式让编译器不要给出参数未被使用的警告 #define MCHECK(ret) ({ __typeof__ (ret) errnum = (ret); \ assert(errnum == 0); (void) errnum;}) #endif // CHECK_PTHREAD_RETURN_VALUE // 防止错误的用法 #define MutexLockGuard(x) error "Missing guard object name"没有注释的代码，里面有些小问题，我们可以总结一下
__builtin_expect
提供给程序员使用的，目的是将“分支转移”的信息提供给编译器，这样编译器可以对代码进行优化，以减少指令跳转带来的性能下降。
函数声明如下
long __builtin_expect(long exp, long c);
exp 为一个整型表达式, 例如: (ptr != NULL)
c 必须是一个编译期常量, 不能使用变量
返回值等于 第一个参数 exp
这个函数的语义是：你期望exp表达式的值等于常量c，从而GCC为你优化程序，将符合这个条件的分支放在合适的地方。
__assert_perror_fail (errnum, __FILE__, __LINE__, __func__) 最后会按照FILE ：LINE ： func : errnum打印出错误，和assert一样，都在编译时候执行，但是好处在于它能按照格式打印出错误在哪里，便于快速排查出错误。
Condition的实现
如果直接使用我们上面实现的Mutex，会出现死锁。
因为在我们使用Conditon的wait的时候：
释放Mutex
阻塞等待
当其它线程调用pthread_cond_signal或pthread_cond_signal,它会重写获取锁。
这个时候，pthread_cond_wait势必会改变pthread_mutex_t和MutexLock:holder的一致性。所以需要在调用pthread_cond_wait的前后添加一些代码去相应的修改*MutexLock::holder，也就是分别调用MutexLock::unassignHolder和MutexLock::assignHolder。MutexLock::UnassignGuard类的作用，就是利用RAII简化对MutexLock::unassignHolder和MutexLock::assignHolder的调用。*
所以在Ｍutex中我们需要加入unassignGuard类
class Mutex { ... private: friend class Condition; class UnassignGuard : boost::noncopyable { public: UnassignGuard(MutexLock& owner) : owner_(owner) { owner_.unassignHolder(); } ~UnassignGuard() { owner_.assignHolder(); } private: MutexLock& owner_; }; ... };这样我们就可以实现Conditon了
class Condition : boost::noncopyable { public: explicit Condition(MutexLock& mutex) : mutex_(mutex) { MCHECK(pthread_cond_init(&pcond_, NULL)); } ~Condition() { MCHECK(pthread_cond_destroy(&pcond_)); } void wait() { MutexLock::UnassignGuard ug(mutex_); //先将holder_清零，防止出现死锁 MCHECK(pthread_cond_wait(&pcond_, mutex_.getPthreadMutex())); // 析构的时候，会将holder_恢复 } // returns true if time out, false otherwise. bool waitForSeconds(double seconds); void notify() { MCHECK(pthread_cond_signal(&pcond_)); } void notifyAll() { MCHECK(pthread_cond_broadcast(&pcond_)); } void waitForSeconds(double seconds) { struct timespec abstime; // FIXME: use CLOCK_MONOTONIC or CLOCK_MONOTONIC_RAW to prevent time rewind. clock_gettime(CLOCK_REALTIME, &abstime); const int64_t kNanoSecondsPerSecond = 1000000000; int64_t nanoseconds = static_cast<int64_t>(seconds * kNanoSecondsPerSecond); abstime.tv_sec += static_cast<time_t>((abstime.tv_nsec + nanoseconds) / kNanoSecondsPerSecond); abstime.tv_nsec = static_cast<long>((abstime.tv_nsec + nanoseconds) % kNanoSecondsPerSecond); MutexLock::UnassignGuard ug(mutex_); return ETIMEDOUT == pthread_cond_timedwait(&pcond_, mutex_.getPthreadMutex(), &abstime); } private: MutexLock& mutex_; pthread_cond_t pcond_; }; CountDownLatch的实现
我们有时对Condition类上面再套一层封装来使用，他就是我们的CountDownLatch类。通过倒计时计数器的方式，设置计数。倒计时未完，CountDownLatch的内部一直处于
Condition类的wait()状态。倒计时完毕，唤醒cond，程序正常执行。所以我们可以给某件即将发生的事设置一个条件，比如至少5个满足才会触发该事件，那么计数值设为5，
等到倒计时为0时，CountDownLatch类就可以让你顺利的去执行该事件了。
所以它主要有两个用法：
1.既可以用于所有子线程主动等待主线程发起“起跑”
2.也可以用于主线哼等待子线程初始化完毕才开始工作
class CountDownLatch : boost::noncopyable { public: explicit CountDownLatch(int count) : mutex_(), condition_(mutex_), count_(count) { } void wait() { MutexLockGuard lock(mutex_); while (count_ > 0) { condition_.wait(); } } void countDown() { MutexLockGuard lock(mutex_); --count_; if (count_ == 0) { condition_.notifyAll(); } } int getCount() const { MutexLockGuard lock(mutex_); return count_; } private: mutable MutexLock mutex_; Condition condition_; int count_; };
