并发编程（二）：分析Boost对 互斥量和条件变量的封装及实现生产者消费者问题

请阅读上篇文章《并发编程实战： POSIX 使用互斥量和条件变量实现生产者/消费者问题》。当然不阅读亦不影响本篇文章的阅读。

Boost的互斥量，条件变量做了很好的封装，因此比“原生的”POSIX mutex，condition variables好用。然后我们会通过分析boost相关源码看一下boost linux是如何对pthread_mutex_t和pthread_cond_t进行的封装。

首先看一下condition_variable_any的具体实现，代码路径：/boost/thread/pthread/condition_variable.hpp

class condition_variable_any
{
    pthread_mutex_t internal_mutex;
    pthread_cond_t cond;

    condition_variable_any(condition_variable_any&);
    condition_variable_any& operator=(condition_variable_any&);

public:
    condition_variable_any()
    {
        int const res=pthread_mutex_init(&internal_mutex,NULL);
        if(res)
        {
            boost::throw_exception(thread_resource_error());
        }
        int const res2=pthread_cond_init(&cond,NULL);
        if(res2)
        {
            BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
            boost::throw_exception(thread_resource_error());
        }
    }
    ~condition_variable_any()
    {
        BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
        BOOST_VERIFY(!pthread_cond_destroy(&cond));
    }
 

condition_variable_any的构造函数是对于内部使用的mutex和cond的初始化，对应的，析构函数则是这些资源的回收。

BOOST_VERIFY的实现：

#undef BOOST_VERIFY
#if defined(BOOST_DISABLE_ASSERTS) || ( !defined(BOOST_ENABLE_ASSERT_HANDLER) && defined(NDEBUG) )
// 在任何情况下，expr一定会被求值。
#define BOOST_VERIFY(expr) ((void)(expr))
#else
#define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
#endif  

因此不同于assert在Release版的被优化掉不同，我们可以放心的使用BOOST_VERITY，因此它的表达式肯定会被求值，而不用担心assert的side effect。
接下来看一下condition_variable_any的核心实现：wait

   template<typename lock_type>
    void wait(lock_type& m)
    {
        int res=0;
        {
            thread_cv_detail::lock_on_exit<lock_type> guard;
            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
            guard.activate(m);
            res=pthread_cond_wait(&cond,&internal_mutex);
            this_thread::interruption_point();
        }
        if(res)
        {
            boost::throw_exception(condition_error());
        }
    }

首先看一下lock_on_exit：

namespace thread_cv_detail
{
    template<typename MutexType>
    struct lock_on_exit
    {
        MutexType* m;

        lock_on_exit():
            m(0)
        {}

        void activate(MutexType& m_)
        {
            m_.unlock();
            m=&m_;
        }
        ~lock_on_exit()
        {
            if(m)
            {
                m->lock();
            }
       }
    };
}

代码很简单，实现了在调用activate时将传入的lock解锁，在该变量生命期结束时将guard的lock加锁。

接下来的detail::interruption_checker check_for_interruption(&internal_mutex,&cond);是什么意思呢？From /boost/thread/pthread/thread_data.hpp

class interruption_checker
{
    thread_data_base* const thread_info;
    pthread_mutex_t* m;
    bool set;

    void check_for_interruption()
    {
        if(thread_info->interrupt_requested)
        {
            thread_info->interrupt_requested=false;
            throw thread_interrupted();
        }
    }

    void operator=(interruption_checker&);
public:
    explicit interruption_checker(pthread_mutex_t* cond_mutex,pthread_cond_t* cond):
        thread_info(detail::get_current_thread_data()),m(cond_mutex),
        set(thread_info && thread_info->interrupt_enabled)
    {
        if(set)
        {
            lock_guard<mutex> guard(thread_info->data_mutex);
            check_for_interruption();
            thread_info->cond_mutex=cond_mutex;
            thread_info->current_cond=cond;
            BOOST_VERIFY(!pthread_mutex_lock(m));
        }
        else
        {
            BOOST_VERIFY(!pthread_mutex_lock(m));
        }
    }
    ~interruption_checker()
    {
        if(set)
        {
            BOOST_VERIFY(!pthread_mutex_unlock(m));
            lock_guard<mutex> guard(thread_info->data_mutex);
            thread_info->cond_mutex=NULL;
            thread_info->current_cond=NULL;
        }
        else
        {
            BOOST_VERIFY(!pthread_mutex_unlock(m));
        }
    }

代码面前，毫无隐藏。那句话就是此时如果有interrupt，那么就interrupt吧。否则，lock传入的mutex，也是为了res=pthread_cond_wait(&cond,&internal_mutex);做准备。

关于线程的中断点，可以移步《【Boost】boost库中thread多线程详解5——谈谈线程中断》。

对于boost::mutex，大家可以使用同样的方法去解读boost的实现，相对于condition variable，mutex的实现更加直观。代码路径：/boost/thread/pthread/mutex.hpp。

namespace boost
{
    class mutex
    {
    private:
        mutex(mutex const&);
        mutex& operator=(mutex const&);
        pthread_mutex_t m;
    public:
        mutex()
        {
            int const res=pthread_mutex_init(&m,NULL);
            if(res)
            {
                boost::throw_exception(thread_resource_error());
            }
        }
        ~mutex()
        {
            BOOST_VERIFY(!pthread_mutex_destroy(&m));
        }

        void lock()
        {
            int const res=pthread_mutex_lock(&m);
            if(res)
            {
                boost::throw_exception(lock_error(res));
            }
        }

        void unlock()
        {
            BOOST_VERIFY(!pthread_mutex_unlock(&m));
        }

        bool try_lock()
        {
            int const res=pthread_mutex_trylock(&m);
            if(res && (res!=EBUSY))
            {
                boost::throw_exception(lock_error(res));
            }

            return !res;
        }

        typedef pthread_mutex_t* native_handle_type;
        native_handle_type native_handle()
        {
            return &m;
        }

        typedef unique_lock<mutex> scoped_lock;
        typedef detail::try_lock_wrapper<mutex> scoped_try_lock;
    };
}

boost对于pthread_mutex_t和pthread_cond_t的封装，方便了开发者的使用的资源的安全有效管理。当然，在不同的公司，可能也都有类似的封装，学习boost的源码，无疑可以加深我们的理解。在某些特定的场合，我们也可以学习boost的封装方法，简化我们的日常开发。

最后，奉上简单的生产者、消费者的boost的实现，和前文《并发编程实战： POSIX 使用互斥量和条件变量实现生产者/消费者问题》相比，我们可以看到boost简化了mutex和condition variable的使用。以下代码引自《Boost程序库完全开发指南》：

#include <boost/thread.hpp>
#include <stack>
using std::stack;
using std::cout;
class buffer
{
private:
    boost::mutex mu; // 条件变量需要配合互斥量
    boost::condition_variable_any cond_put; // 生产者写入
    boost::condition_variable_any cond_get; // 消费者读走

    stack<int> stk;
    int un_read;
    int capacity;

    bool is_full()
    {
        return un_read == capacity;
    }
    bool is_empty()
    {
        return 0 == un_read;
    }

public:
    buffer(size_t capacity) : un_read(0), capacity(capacity)
    {}
    void put(int x)
    {

        boost::mutex::scoped_lock lock(mu); // 这里是读锁的门闩类

        while (is_full())
        {
            cout << "full waiting..." << endl;
            cond_put.wait(mu); // line:51
        }
        stk.push(x);
        ++un_read;

        cond_get.notify_one();
    }
    void get(int *x)
    {
        boost::mutex::scoped_lock lock(mu); // 这里是读锁的门闩类

        while (is_empty())
        {
            cout << "empty waiting..." << endl;
            cond_get.wait(mu);
        }
        *x = stk.top();
        stk.pop();
        --un_read;

        cond_put.notify_one(); // 通知 51line可以写入了
    }
};

buffer buf(5); 

void producer(int n)
{
    for (int i = 0; i < n; ++i)
    {
        cout << "put : " << i << endl;
        buf.put(i);
    }
}

void consumer(int n)
{
    int x;
    for (int i = 0; i < n; ++i)
    {
        buf.get(&x);
        cout << "get : " << x << endl;
    }
}

int main()
{
    boost::thread t1(producer, 20);
    boost::thread t2(consumer, 10);
    boost::thread t3(consumer, 10);

    t1.join();
    t2.join();
    t3.join();

    return 0;
}

最后说一句，condition_variable_any == condition, from /boost/thread/condition.hpp

namespace boost
{
    typedef condition_variable_any condition;
}