boost::shared

boost::shared_mutex

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

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

[cpp] view plaincopy  
 print?
 mutex::scope_lock lock(mu);  

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

[cpp] view plaincopy  
 print?
 shared_mutex rw_mu;  
   
 unique_lock<shared_mutex> ul(rw_mu);  
 shared_lock<shared_mutex> sl(rw_mu);  

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

[cpp] view plaincopy  
 print?
 private:  
         int m_x;  
         shared_mutex rw_mu;  
   
 public:  
         rw_data():m_x(0){}  
   
         void write()  
         {  
             unique_lock<shared_mutex> ul(rw_mu);  
             ++m_x;  
         }  
   
         void read(int& x)  
         {  
             shared_lock<shared_mutex> 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;  
 }  