（Boost）mutex scoped_lock

90 阅读 0 评论 60 点赞

我是靠谱客的博主淡然夕阳，最近开发中收集的这篇文章主要介绍（Boost）mutex scoped_lock，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

原文：http://www.cnblogs.com/liuweilinlin/p/3255846.html

1.boost里的互斥量类型由mutex表示。

代码示例：

 
          #include <iostream> 
         
          #include <string> 
         
          #include <vector> 
         
          #include <boost/thread.hpp> 
         
          #include <boost/thread/mutex.hpp> 
         
          using 
          namespace 
          std; 
         
          using 
          namespace 
          boost; 
         
          int 
           main() 
         
          { 
         
          mutex mu; 
         
          try 
         
          { 
         
          this_thread::sleep(posix_time::seconds(2)); 
         
          mu.lock(); 
          //锁定cout对象 
         
          cout << 
          "Some operations" 
          <<endl; 
         
          mu.unlock(); 
         
          } 
         
          catch 
          ( 
          int 
          ) 
         
          { 
         
          mu.unlock(); 
         
          return 
          0; 
         
          } 
         
          }

2.上面的代码好像似曾相识，是的，在防止内存泄露的时候采用的和上面类似的处理方式，更加简洁的方式是智能指针，类似的我们需要用智能锁改写上面的代码scoped_lock智能锁。

 
          #include <iostream> 
         
          #include <string> 
         
          #include <vector> 
         
          #include <boost/thread.hpp> 
         
          #include <boost/thread/mutex.hpp> 
         
          using 
          namespace 
          std; 
         
          using 
          namespace 
          boost; 
         
          template 
          < 
          typename 
          T> 
         
          class 
          basic_atom:noncopyable 
         
          { 
         
          private 
          : 
         
          T n; 
         
          typedef 
          mutex mutex_t; 
         
          mutex_t mu; 
         
          public 
          : 
         
          basic_atom(T x = T()):n(x){} 
         
          T operator++() 
         
          { 
         
          mutex_t::scoped_lock lock(mu); 
         
          return 
          ++n; 
         
          } 
         
          operator T(){ 
          return 
          n;} 
         
          }; 
         
          int 
           main() 
         
          { 
         
          return 
          0; 
         
          }