事实上，muduo中对互斥量和条件变量的操作基本上都是调用它们对应的相关函数来实现的。例如MutexLock::lock()即调用pthread_mutex_lock()，Condition::wait()即调用pthread_cond_wait()等等。

互斥量

muduo封装了MutexLock和MutexLockGuard。MutexLock封装临界区，它是一个简单的资源类，用RAII手法封装互斥量的创建与销毁，MutexLock一般是别的类的数据成员。MutexLockGuard封装临界区的进入和退出，即加锁和解锁，它一般是个栈上对象，作用域刚好等于临界区域。

类图：

(1)需要理解的是使用RAII(资源获取就是初始化)手法封装MutexLockGuard：不手工调用lock()和unlock()函数，一切交给栈上的Guard对象的构造和析构函数负责。

(2)互斥锁通常用于保护由多个线程或多进程分享的共享数据，一般是一些可供线程间使用的全局变量，来达到线程同步的目的，即保证任何时刻只有一个线程或进程在执行其中的代码。一般加锁的轮廓如下：

pthread_mutex_lock()
临界区
pthread_mutex_unlock()

(3)互斥量相关函数

互斥锁的初始化有两种初始化方式：

I.对于静态分配的互斥锁一般用宏赋值的方式初始化，
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

II.对于动态分配的互斥锁（如调用malloc）或分配在共享内存中，则必须调用pthread_mutex_init()函数来进行初始化。

#include <pthread.h>  

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);  // 参数mutexattr指定互斥量的属性，NULL为默认属性

// pthread_mutex_lock和pthread_mutex_unlock都是原子操作
// 如果一个线程调用pthread_mutex_lock试图锁住互斥量，而该互斥量，又被其他线程锁住（占用）
// 则该线程的pthread_mutex_lock调用就会阻塞直到其他线程对该互斥量进行解锁，该线程才能获得该互斥量
// pthread_mutex_lock调用才会返回  
int pthread_mutex_lock(pthread_mutex_t *mutex);   
int pthread_mutex_unlock(pthread_mutex_t *mutex);  

int pthread_mutex_destroy(pthread_mutex_t *mutex); 

返回值：成功时返回0，失败时返回错误代码，它们并不设置errno

(4)作者在Mutex.h代码的最后一行还定义了一个宏：

// Prevent misuse like:
// MutexLockGuard(mutex_);
// A tempory object doesn't hold the lock for long!
#define MutexLockGuard(x) error "Missing guard object name"

它的作用是防止程序里出现如下错误：

void doit()
{
    MutexLockGuard(mutex);  // 遗漏了变量名，产生一个临时对象又马上销毁了
                            // 结果没有锁住临界区
    // 正确写法是 MutexLockGuard lock(mutex);
}

条件变量

如果需要等待某个条件成立，我们应该使用条件变量，条件变量顾名思义是一个或多个线程等待某个布尔表达式为真，即等待别的线程“唤醒”它，条件变量的使用是与互斥锁共同使用的。

muduo Condition类图：

(1)条件变量相关函数

#include <pthread.h>

// pthread_cond_t类型的变量可以用PTHREAD_COND_INITIALIZER常量进行静态初始化
pthread_cond_t cond = PTHREAD_COND_INITIALIZER; 

// 初始化。当cond_attr为NULL时，使用缺省的属性
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr); 

// 唤醒等待在相应条件变量上的一个线程
int pthread_cond_signal(pthread_cond_t *cond); 

// 唤醒阻塞在相应条件变量上的所有线程
int pthread_cond_broadcast(pthread_cond_t *cond); 

// 会自动解锁互斥量，等待条件变量被触发
// 在调用pthread_cond_wait之前，应用程序必须加锁互斥量
// pthread_cond_wait函数返回前，自动重新对互斥量加锁
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); 

// 允许线程就阻塞时间设置一个限制值
// 如果在abstime指定的时间内cond未触发，互斥量mutex被重新加锁且pthread_cond_timedwait返回错误ETIMEDOUT
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime); 

// 销毁一个条件变量，释放它拥有的资源
int pthread_cond_destroy(pthread_cond_t *cond); 

(2)需要注意的是：如果一个class要包含MutexLock和Condition，要注意它们的声明顺序和初始化顺序（初始化顺序要与成员声明保持一致），mutex_应先于condition_构造，并作为后者的构造参数。

(3)clock_gettime函数和struct timespec结构
Contidion::waitForSeconds()用到了clock_gettime函数设置限制时间。

#include <time.h>

// 最高精度为纳秒
struct timespec {
    time_t tv_sec;  // seconds 
    long tv_nsec;   // nanoseconds 
};

// clock_gettime函数原型
// 可以用于计算精度和纳秒
long sys_clock_gettime (clockid_t which_clock, struct timespec *tp);

which_clock参数解释：
1.CLOCK_REALTIME:系统实时时间,随系统实时时间改变而改变,即从UTC1970-1-1 00:00:00开始计时,中间时刻如果系统时间被用户该成其他,则对应的时间相应改变
2.CLOCK_MONOTONIC:从系统启动这一刻起开始计时,不受系统时间被用户改变的影响
3.CLOCK_PROCESS_CPUTIME_ID:本进程到当前代码系统CPU花费的时间
4.CLOCK_THREAD_CPUTIME_ID:本线程到当前代码系统CPU花费的时间

利用条件变量实现的倒计时门闩类

类图：

倒计时是一种常用且易用的同步手段，它主要有两种用途：
(1)主线程发起多个子线程，等这些子线程各自都完成一定的任务之后，主线程才继续执行。通常用于主线程等待多个子线程完成初始化。
(2)主线程发起多个子线程，子线程都等待主线程，主线程完成其他一些任务之后通知所有子线程开始执行。通常用于多个子线程等待主线程发出“起跑”命令。

CountDownLatch的接口和实现很简单：

文件名：CountDownLatch.h

class CountDownLatch : boost::noncopyable
{
public:
  explicit CountDownLatch(int count);  // count表示倒数几次
  void wait();  // 等待计数值变为0
  void countDown();  // 计数减一
  int getCount() const;

private:
  mutable MutexLock mutex_;
  Condition condition_;
  int count_;
};

文件名：CountDownLatch.cc

void CountDownLatch::wait()
{
    MutexLockGuard lock(mutex_);
    while(count_ > 0)
        condition_.wait();
}

void CountDownLatch::countDown()
{
    MutexLockGuard lock(mutex_);
    --count_;
    if(count_ == 0)
        conditon_.notifyAll();
}