boost条件变量(condition_variable)wait操作传

本文也标题党了一回。因为在boost开发者眼里，这肯定不是bug，甚至算不上flaw，而是character,详见#2219 This works as designed 云云。如果搞懂原理后正确使用也一切OK，不过我觉得作为一个高质量的库，不应该对开发者提出这么高的要求，另外这个问题让我半夜调试鸡飞狗跳，难免带些情绪，所以姑且称其为bug吧。
      先说几句题外话：条件变量是并发开发的一大利器。君不见java提供的基本同步机制只有synchronize（相当于同线程可重入的临界区recursive mutex)和wait/notify(这就是条件变量了)，虽然还有其他几个同步原语，但是都是deprecate的。使用条件变量开发并发应用的最大优势是更容易做对，也更容易阅读理解。并发应用是很难调试的，有的bug可以潜伏很久直到哪天把程序崩掉，所以这两点是很关键的。boost的thread库提供有recursive_mutex、condition_variable和condition_variable_any。condition_variable_any可以作用于任意的mutex，那是不是利用boost::recursive_mutex和boost::condition_variable_any，就可以programming c++ like java ? 在今天之前我是这么认为的，但事实证明没这么简单。
      先来看一个例子：
#include "xttime.h"
#include <iostream>
#include <boost/thread.hpp>

using namespace std;

class TestVC
{
public:

      TestVC()
      {
            running_flag = true;           
      }

      void stop()
      {
            running_flag = false;
            {
                  boost::recursive_mutex::scoped_lock lock(mtx);
                  cond.notify_all();
            }
      }

      void waitSignalThread()
      {
            boost::recursive_mutex::scoped_lock lock(mtx);     
            while(running_flag)
            {
                  cout << "start wait signal" << endl;                 
                  cond.wait(mtx);
                  cout << "finish wait signal" << endl;                 
            }
      }

      void emitSignalThread()
      {
            while (running_flag)
            {
                  {
                        boost::recursive_mutex::scoped_lock lock(mtx);
                        cout << "start emit singal" << endl;
                        cond.notify_all();
                        cout << "finish emit signal" << endl;
                  }
                  global::sleepms(10);
            }
      }

private:

      bool running_flag;
      boost::recursive_mutex mtx;
      boost::condition_variable_any cond;

};

int main()
{
      boost::thread_group grp;
      TestVC test;
     
      grp.create_thread(boost::bind(&TestVC::waitSignalThread, &test));
      grp.create_thread(boost::bind(&TestVC::emitSignalThread, &test));
           
      global::sleepms(100);
      test.stop();
      grp.join_all();

      return 0;
}

      例子很简单，运行后跟预期的一样，循环打印：start wait signal、start emit singal、finish emit signal、finish wait signal。接下来做一个小改动：将waitSignalThread分解成两个函数如下：
      void waitOneSignal()
      {
            boost::recursive_mutex::scoped_lock lock(mtx);     
            cout << "start wait signal" << endl;                 
            cond.wait(mtx);
            cout << "finish wait signal" << endl;     
      }

      void waitSignalThread()
      {
            boost::recursive_mutex::scoped_lock lock(mtx);                 
            while(running_flag)
            {
                  waitOneSignal();                             
            }
      }

      结果呢？非常不幸跟预期的不同，打印start wait signal后程序堵住了。这是因为boost::condition_variable_any只知道它的参数是一个可以加解锁的对象，所以调用wait的时候只是进行了一次解锁操作，但是当waitOneSignal调用cond.wait(mtx)的时候，mtx被加锁了两次了，只解锁一次，emitSignal线程当然无法获取mtx的锁。
      解决方法关键在于条件变量要知道自己获得的lockable对象是recursive_mutex，在wait之前调用若干次unlock，wait后相应调用若干次lock（否则部分临界区将失去保护），代码如下（仅适用于win32平台，因为linux下的recursive_mutex是通过pthread的PTHREAD_MUTEX_RECURSIVE模式来实现的，没有保存当前加锁次数）：
class condition_variable_recursive_mutex
{
public:

      condition_variable_recursive_mutex(){}
      ~condition_variable_recursive_mutex(){}

      void wait(boost::recursive_mutex& mtx)
      {
            int extra_lock = mtx.recursion_count - 1;
            for (int i = 0; i < extra_lock; i++)
            {
                  mtx.unlock();
            }
            XASSERT(mtx.recursion_count == 1);           
            cond.wait(mtx);           
            for (int i = 0; i < extra_lock; i++)
            {
                  mtx.lock();
            }
      }

      void notify_one()
      {
            cond.notify_one();
      }

      void notify_all()
      {
            cond.notify_all();
      }

private:

      boost::condition_variable_any cond;
};
      当使用recursive_mutex时使用上文condition_variable_recursive_mutex替代boost自带的条件变量就可以避免发生解锁不彻底的问题。如果要使用boost自带的条件变量也不是不行，只要确保wait的时候mutex只锁了一次即可——避免范围加锁的函数互相调用（如例子）和范围加锁的递归函数就可以基本满足这点了——这是挺麻烦的。
      最后一个问题：linux怎么办？事实上，我更关心Linux上能否正常运行。我感觉这是pthread接口设计的一个瑕疵：既然可以递归锁，为何没有方法获知总计锁了几次？为recursive_mutex加上计数即可最终解决该问题。

class xrecursive_mutex
{
public:
      xrecursive_mutex(): recursion_count(0){}
      ~xrecursive_mutex(){}

      //      serious warning: you must only call this func in the thread already hold permission of this mutex!
      int get_recursion_count()
      {                 
            return recursion_count;
      }

      void lock()
      {
            mutex.lock();
            ++ recursion_count;
      }

      //      serious warning: you must only call this func in the thread already hold permission of this mutex!
      void unlock()
      {
            -- recursion_count;
            mutex.unlock();                 
      }

      //      lock of RAII style
      class scoped_lock
      {
      public:
            scoped_lock(xrecursive_mutex& mtx_)
                  : mtx(mtx_)
            {
                  mtx.lock();
            }

            ~scoped_lock()
            {
                  mtx.unlock();
            }

      private:           
            xrecursive_mutex& mtx;
      };

private:

      int recursion_count;
      boost::recursive_mutex mutex;
};

class condition_variable_recursive_mutex
{
public:
      condition_variable_recursive_mutex(){}
     
      ~condition_variable_recursive_mutex(){}

      void wait(xrecursive_mutex& mtx)
      {
            int extra_lock = mtx.get_recursion_count() - 1;
            for (int i = 0; i < extra_lock; i++)
            {
                  mtx.unlock();
            }
            XASSERT(mtx.get_recursion_count() == 1);           
            cond.wait(mtx);           
            for (int i = 0; i < extra_lock; i++)
            {
                  mtx.lock();
            }
      }

      void notify_one()
      {
            cond.notify_one();
      }

      void notify_all()
      {
            cond.notify_all();
      }

private:
      boost::condition_variable_any cond;
};