Muduo库源码分析（5）：互斥锁，条件变量类

互斥锁（muduo库简单的封装）

将muduo库的线程id的操作去除的简单版本

// 出错处理
#define MCHECK(ret) ({ __typeof__ (ret) errnum = (ret); assert(errnum == 0); (void) errnum;})
class MutexLock : noncopyable
{
public:
MutexLock()
{
// 初始化互斥锁
MCHECK(pthread_mutex_init(&mutex_, NULL));
}

~MutexLock()
{
// 销毁互斥锁
MCHECK(pthread_mutex_destroy(&mutex_));
}

void lock()
{
// 加锁
MCHECK(pthread_mutex_lock(&mutex_));
}

void unlock()
{
// 解锁
MCHECK(pthread_mutex_unlock(&mutex_));
}

pthread_mutex_t* getPthreadMutex()
{
// 获取锁
return &mutex_;
}

private:
pthread_mutex_t mutex_;// 互斥锁
};

// 对加锁和解锁操作进行封装，采用的是C++的RAII机制，好处是不需要手动进行解锁操作，由MutexLockGuard类自动管理解锁操作（析构函数完成）。
链接：[http://www.cnblogs.com/gnuhpc/archive/2012/12/04/2802307.html "C++ RAII机制"]
class MutexLockGuard : noncopyable
{
public:
explicit MutexLockGuard(MutexLock& mutex)
: mutex_(mutex)
{
mutex_.lock();
}

~MutexLockGuard()
{
mutex_.unlock();
}
private:
MutexLock& mutex_;// 采用的是引用，目的是该类只负责加锁和解锁，而互斥量的销毁由MutexLock类负责
};
// 阻止匿名互斥量的操作
#define MutexLockGuard(x) error "Missing guard object name"

条件变量类封装

class Condition : noncopyable
{
public:
explicit Condition(MutexLock& mutex)
: mutex_(mutex)
{
// 条件变量初始化
MCHECK(pthread_cond_init(&pcond_, NULL));
}

~Condition()
{
// 消除条件变量
MCHECK(pthread_cond_destroy(&pcond_));
}

void wait()
{
MCHECK(pthread_cond_wait(&pcond_,mutex_.getPthreadMutex()));
}

void notify()
{
MCHECK(pthread_cond_signal(&pcond_));
}

void notifyAll()
{
MCHECK(pthread_cond_broadcast(&pcond_));
}
bool waitForSeconds(double seconds)
{
struct timespec abstime;
clock_gettime(CLOCK_REALTIME, &abstime);
const int64_t kNanoSecondsPerSecond = 1e9;
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类：

可实现子进程等待主进程发起命令后竞争执行

（主线程调用countDown,子线程调用wait）

也可实现主线程等待子进程初始化完成后在执行

（主线程调用wait,子线程调用countDown）

class CountDownLatch : noncopyable
{
public:

explicit CountDownLatch(int 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_;// 声明为mutable的目的是因为getCount函数声明为const函数而该函数会改变锁的状态
Condition condition_;
int count_;
};