muduo_base库学习笔记6——互斥量、条件变量和倒计时门闩类

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

互斥量

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

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

pthread_mutex_lock()
临界区
pthread_mutex_unlock()

看看MutexLock代码

MutexLock中：holder_当前拥有该锁的线程id， 即tid，线程的真实id， 构造函数，析构函数，是否当前线程拥有该锁，断言当前线程拥有该所，加锁，解锁，获取pthread_mutex_t当前对象

继承自noncopyable不可拷贝，在构造函数中初始化mutex，并且将holder_初始化为0表示当前锁没有被任何一个线程拥有； 析构函数中， 断言holder_等于0， 断言这个锁没有被任何线程拥有，我们才可以去销毁这个锁

判断当前线程受否拥有锁，只要判断holder_是否等于当前tid， lock()和unlock()就是调用pthread_mutex_lock/unlock然后更新holder_就好

看看MutexLockGuard

采用 RAII(资源获取就是初始化)手法封装MutexLockGuard：不用手动调用lock()和unlock()函数，一切交给栈上的Guard对象的构造和析构函数负责。
在应用中这个类更加常用，因为MutexLock存在死锁的风险，需要自己记得lock和unlock，而MutexLockGuard则不用，可以避免死锁，另外注意MutexLockGuard仅仅只是使用了mutex_的引用，其生存期不归MutexLockGuard管理，析构的时候斌没有去释放这个对象，MutexLockGuard和MutexLock这两个类仅仅是关联关系， MutexLockGuard仅仅是使用了MutexLock的lock()和unlock()

代码：

构造函数中调用lock()，构造函数中调用unlock()
还最后一行还定义了一个宏：

// 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);
}

不允许构造一个匿名的MutexLockGuard对象， 一个临时的匿名对象不能够长时间的拥有锁

简单总结互斥量相关函数：

互斥锁的初始化有两种初始化方式 ：
1，静态分配的互斥锁一般用宏赋值的方式初始化
pthread_mutex_t = PTHREAD_MUTEX_INITIALIZER;
2，动态分配的互斥锁（如调用mallco）或分配在共享内存中，则把必须调用pthread_mutex_init()函数进行初始化

#include <pthread.h>  

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);  // 参数mutexattr指定互斥量的属性，NULL为默认属性 
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；
pthread_mutex_lock和pthread_mutex_unlock都是原子操作
如果一个线程调用pthread_mutex_lock试图锁住互斥量，而该互斥量，又被其他线程锁住（占用），则该线程的pthread_mutex_lock调用就会阻塞直到其他线程对该互斥量进行解锁，该线程才能获得该互斥量pthread_mutex_lock调用才会返回

条件变量

如果需要等待某个条件成立，就需要使用条件变量，即一个线程或多个线程等待某个布尔表达式为真，即等待别的线程“唤醒”它，条件变量的使用是与互斥锁共同使用的
构造函数、析构函数、等待函数、等待一定时间、signal函数、broadcast函数

简单的条件变量相关函数：

#include<pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;//静态初始化
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);//唤醒阻塞等待在相应条件变量上的所有线程

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


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

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

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

clock_gettime函数和struct timespec结构

#include<time.h>

struct timespec 
{
	time_t tv_sec;
	long tv_nsec;
};

//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花费的时间

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

倒计时是一种常用且易用的同步手段，它主要有两种用途：
(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();
}

、
之后自己test一下测试一下吧， 以后看源码应该都是测试着去学吧