muduo网络库源码学习————条件变量

muduo里的CountDownLatch类实际上是对条件变量condition进行的封装，既可以用于所有子线程等待主线程发起 “起跑” ，也可以用于主线程等待子线程初始化完毕才开始工作。

condition.h代码如下：

// Use of this source code is governed by a BSD-style license
// that can be found in the License file.
//
// Author: Shuo Chen (chenshuo at chenshuo dot com)
//条件变量
#ifndef MUDUO_BASE_CONDITION_H
#define MUDUO_BASE_CONDITION_H

#include <muduo/base/Mutex.h>

#include <boost/noncopyable.hpp>
#include <pthread.h>

namespace muduo
{

class Condition : boost::noncopyable
{
 public:
    //构造函数只能显式调用
  explicit Condition(MutexLock& mutex) : mutex_(mutex)
  {//构造函数初始化条件变量
    pthread_cond_init(&pcond_, NULL);
  }
    //析构函数
  ~Condition()
  {//析构函数销毁条件变量
    pthread_cond_destroy(&pcond_);
  }
    //等待函数
  void wait()
  {
    pthread_cond_wait(&pcond_, mutex_.getPthreadMutex());
  }

  // returns true if time out, false otherwise.
  bool waitForSeconds(int seconds);
    //signal函数
  void notify()
  {
    pthread_cond_signal(&pcond_);
  }
    //broadcast函数
  void notifyAll()
  {
    pthread_cond_broadcast(&pcond_);
  }

 private:
  MutexLock& mutex_;//锁，不拥有他，是一个引用，不负责管理他的生存期
  pthread_cond_t pcond_;//为一个条件变量
};

}
#endif  // MUDUO_BASE_CONDITION_H

condition.cc

// Use of this source code is governed by a BSD-style license
// that can be found in the License file.
//
// Author: Shuo Chen (chenshuo at chenshuo dot com)

#include <muduo/base/Condition.h>

#include <errno.h>

// returns true if time out, false otherwise.
bool muduo::Condition::waitForSeconds(int seconds)
{
  struct timespec abstime;
  clock_gettime(CLOCK_REALTIME, &abstime);
  abstime.tv_sec += seconds;
  return ETIMEDOUT == pthread_cond_timedwait(&pcond_, mutex_.getPthreadMutex(), &abstime);
}

CountDownLatch.h

// Use of this source code is governed by a BSD-style license
// that can be found in the License file.
//
// Author: Shuo Chen (chenshuo at chenshuo dot com)
//对条件变量的封装，既可以用于所有子线程等待主线程发起起跑命令，
//也可以用于主线程等待子线程初始化完毕才开始工作
#ifndef MUDUO_BASE_COUNTDOWNLATCH_H
#define MUDUO_BASE_COUNTDOWNLATCH_H

#include <muduo/base/Condition.h>
#include <muduo/base/Mutex.h>

#include <boost/noncopyable.hpp>

namespace muduo
{

class CountDownLatch : boost::noncopyable
{
 public:
//构造函数，显示调用
  explicit CountDownLatch(int count);
//等待函数
  void wait();
//计数器减
  void countDown();
//获取当前计数器的值
  int getCount() const;

 private://mutable表明在const里可以改变他的状态
  mutable MutexLock mutex_;//互斥锁
  Condition condition_;//条件变量
  int count_;//计数器
};

}
#endif  // MUDUO_BASE_COUNTDOWNLATCH_H

CountDownLatch.cc

// Use of this source code is governed by a BSD-style license
// that can be found in the License file.
//
// Author: Shuo Chen (chenshuo at chenshuo dot com)

#include <muduo/base/CountDownLatch.h>

using namespace muduo;
//构造函数对值进行初始化，参数为计数器，构造mutex_对象，将mutex_对象传到condition_里面
CountDownLatch::CountDownLatch(int count): mutex_(), condition_(mutex_),count_(count)
{
}

void CountDownLatch::wait()
{
  MutexLockGuard lock(mutex_);
  //count_不为0则一直等待
  while (count_ > 0)
  {
    condition_.wait();
  }
}

void CountDownLatch::countDown()
{
  MutexLockGuard lock(mutex_);
  --count_;//count_减少
  if (count_ == 0)
  {//如果count_为0，则通知所有的等待线程
    condition_.notifyAll();
  }
}

int CountDownLatch::getCount() const
{//得到count_的值
  MutexLockGuard lock(mutex_);
  return count_;
}

测试代码需要自己编写，如下所示，该程序先打印主进程id，建立3个线程，wait等待主线程发号施令，然后睡眠3秒，之后发起号令，打印各个线程的id，代码如下：

#include <muduo/base/CountDownLatch.h>
#include <muduo/base/Thread.h>

#include <boost/bind.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <string>
#include <stdio.h>
//测试程序
using namespace muduo;

class Test
{
 public:
  Test(int numThreads) : latch_(1),threads_(numThreads)
  {//CountDownLatch对象的计数值初始化为1，线程对象数组的容量初始化为传进来的参数
    for (int i = 0; i < numThreads; ++i)
    {//创建numThreads个线程
      char name[32];//线程的名称
      snprintf(name, sizeof name, "work thread %d", i);
      //创建线程，threadFunc为回调函数，因为是成员函数，所以要用&，this为当前类指针
      threads_.push_back(new muduo::Thread(boost::bind(&Test::threadFunc, this), muduo::string(name)));
    }
    //占位符为参数
    for_each(threads_.begin(), threads_.end(), boost::bind(&Thread::start, _1));
  }

  void run()
  {//count_初始化的时候赋为1，这里只需执行一次既可以跳出等待
    latch_.countDown();
  }

  void joinAll()
  {
    for_each(threads_.begin(), threads_.end(), boost::bind(&Thread::join, _1));
  }

 private:

  void threadFunc()
  {
    latch_.wait();//等待主线程发号施令
    printf("tid=%d, %s started\n", CurrentThread::tid(), CurrentThread::name());

    printf("tid=%d, %s stopped\n",CurrentThread::tid(),CurrentThread::name());
  }

  CountDownLatch latch_;//CountDownLatch对象
  boost::ptr_vector<Thread> threads_;//线程对象数组
};

int main()
{//首先打印当前进程pid，当前线程tid
  printf("pid=%d, tid=%d\n", ::getpid(), CurrentThread::tid());
  //构造Test对象
  Test t(3);
  sleep(3);
  printf("pid=%d, tid=%d %s running ...\n", ::getpid(), CurrentThread::tid(), CurrentThread::name());
  t.run();//发号施令
  t.joinAll();

  printf("number of created threads %d\n", Thread::numCreated());
}

由于线程竞争，运行结果不唯一：



另一个结果：