boost::shared_mutex

 前一篇介绍的条件变量可以进行进程间通信，用来实现生产者/消费者模型。今天介绍的共享互斥量用来实现缓冲区读写模型，与生产者/消费者模型不同的地方是，消费者消费产品后，被消费的产品就不存在了，所以消费者线程也要互斥运行；而缓冲区读取线程读取数据后不删除数据，多个线程可以并行读取。这时使用条件变量也不合适了，就要使用共享互斥变量了。

        共享互斥量，顾名思义，既共享，也互斥，读线程之间共享读取数据，使用shared_lock类锁定shared_mutex变量；写线程之间需要独占缓冲区，必须互斥运行，使用unique_lock类锁定shared_mutex变量。这与互斥变量mutex的使用方法不一样，mutex类内部提供了一种lock_guard类即scope_lock类，因此可以用

 mutex::scope_lock lock(mu);

这样的形式来锁定互斥量，而share_mutex类没有提供这种内部定义的lock_guard类，所以需要直接使用lock_guard对象，语法如下代码：

 shared_mutex rw_mu;

 unique_lock ul(rw_mu);
 shared_lock sl(rw_mu);

下面是《指南》上的例子：
 

 private:
         int m_x;
         shared_mutex rw_mu;

 public:
         rw_data():m_x(0){}

         void write()
         {
             unique_lock ul(rw_mu);
             ++m_x;
         }

         void read(int& x)
         {
             shared_lock sl(rw_mu);
             x = m_x;
         }
 };

 void writer(rw_data& d)
 {
     for(int i = 0; i < 20; ++i)
     {
         this_thread::sleep(posix_time::millisec(10));
         d.write();
     }
 }

 void reader(rw_data& d, mutex& io_mu)
 {
     int x;

     for(int i = 0; i < 10; ++i)
     {
         this_thread::sleep(posix_time::millisec(5));
         d.read(x);
         mutex::scoped_lock lock(io_mu);
         std::cout << "reader:" << x << std::endl;
     }
 }

 int main()
 {
    rw_data d;
    thread_group pool;
    mutex io_mu;

    pool.create_thread(bind(reader,ref(d), ref(io_mu)));
    pool.create_thread(bind(reader,ref(d), ref(io_mu)));
    pool.create_thread(bind(reader,ref(d), ref(io_mu)));
    pool.create_thread(bind(reader,ref(d), ref(io_mu)));
    pool.create_thread(bind(writer,ref(d)));
    pool.create_thread(bind(writer,ref(d)));

    pool.join_all();

    return 0;
 }