精华内容
下载资源
问答
  • CP.21: Usestd::lock()orstd::scoped_lockto acquire multiplemutexes CP.21:使用std::lock()或者std::scoped_lock获取多个mutex Reason(原因) To avoid deadlocks on multiplemutexes. 避免在多个mutex上...

    CP.21: Use std::lock() or std::scoped_lock to acquire multiple mutexes

    CP.21:使用std::lock()或者std::scoped_lock获取多个mutex

     

    Reason(原因)

    To avoid deadlocks on multiple mutexes.

    避免在多个mutex上发生死锁。

     

    Example(实例)

    This is asking for deadlock:

    下面的代码会引发死锁:

    // thread 1
    lock_guard<mutex> lck1(m1);
    lock_guard<mutex> lck2(m2);
    
    // thread 2
    lock_guard<mutex> lck2(m2);
    lock_guard<mutex> lck1(m1);
    

    Instead, use lock():

    使用lock代替:

    // thread 1
    lock(m1, m2);
    lock_guard<mutex> lck1(m1, adopt_lock);
    lock_guard<mutex> lck2(m2, adopt_lock);
    
    // thread 2
    lock(m2, m1);
    lock_guard<mutex> lck2(m2, adopt_lock);
    lock_guard<mutex> lck1(m1, adopt_lock);
    

    or (better, but C++17 only):

    或者(可以更好,但仅限于C++17)

    // thread 1
    scoped_lock<mutex, mutex> lck1(m1, m2);
    
    // thread 2
    scoped_lock<mutex, mutex> lck2(m2, m1);
    

    Here, the writers of thread1 and thread2 are still not agreeing on the order of the mutexes, but order no longer matters.

    这里,thread1和thread2的作者仍然没有在获取mutex的顺序上取得一致,但是顺序已经不再重要。

     

    Note(注意)

    In real code, mutexes are rarely named to conveniently remind the programmer of an intended relation and intended order of acquisition. In real code, mutexes are not always conveniently acquired on consecutive lines.

    在实际的代码中,mutex的命名很少能向程序员提示希望的关系和希望的请求次序。在实际的代码中,mute不会总是在相邻代码中执行获取,那样的话问题可能更容易被发现。

     

    In C++17 it's possible to write plain

    在C++17可以简单地这样写:

    lock_guard lck1(m1, adopt_lock);
    

    and have the mutex type deduced.

    这样就可以实现mutex类型推断。

     

    Enforcement(实施建议)

    Detect the acquisition of multiple mutexes. This is undecidable in general, but catching common simple examples (like the one above) is easy.

    检查多重mutex获取操作。这一点通常是不可判定的,但是捕捉一般的简单例子(例如上面的例子)是容易做到的。

     

    原文链接https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#cp21-use-stdlock-or-stdscoped_lock-to-acquire-multiple-mutexes


     

    新书介绍

    以下是本人3月份出版的新书,拜托多多关注!

     

    本书利用Python 的标准GUI 工具包tkinter,通过可执行的示例对23 个设计模式逐个进行说明。这样一方面可以使读者了解真实的软件开发工作中每个设计模式的运用场景和想要解决的问题;另一方面通过对这些问题的解决过程进行说明,让读者明白在编写代码时如何判断使用设计模式的利弊,并合理运用设计模式。

    对设计模式感兴趣而且希望随学随用的读者通过本书可以快速跨越从理解到运用的门槛;希望学习Python GUI 编程的读者可以将本书中的示例作为设计和开发的参考;使用Python 语言进行图像分析、数据处理工作的读者可以直接以本书中的示例为基础,迅速构建自己的系统架构。

     

    觉得本文有帮助?欢迎点赞并分享给更多的人。

    阅读更多更新文章,请关注微信公众号【面向对象思考】

    展开全文
  • scoped_lock

    千次阅读 2018-05-11 01:02:12
    那么是否没有Lock变量情况下,scoped_lock的作用域仅仅是到该行的“;”就结束了呢? 为了验证这个想法,我写了如下代码,通过对象何时析构来证实该想法: [cpp] view plain copy #include    #include    ...
    一个由于锁的作用域导致core dump的问题的解决

    请看如下代码:

    1. void CCommParams::setParams( const char * authUser,   
    2.                         const char * authPsw,  
    3.                         const char * securityLevel,   
    4.                         const char * portNumber)  
    5. {  
    6.     boost::mutex::scoped_lock(m_runtimeMutex);  
    7.     std::string SecLevel = (NULL == securityLevel)? "" : securityLevel;  
    8.     std::string nPort =  (NULL == portNumber)? 0 : atoi(portNumber);  
    9.     std::string AuthUsr = (NULL == authUser)? "" : authUser;  
    10.     std::string AuthPwd = (NULL == authPsw)? "" : authPsw;  
    11.     m_szSecLevel =SecLevel;  
    12.     m_szUsrName = authUser;  
    13.     m_szPwd =authPsw;  
    14.     m_dwPort = nPort;  
    15. }  


    问题的提出:
    在多线程环境下, 如果又多个线程同时调用以上函数setParams,发现总是core dump.
    通过gdb bt发现,问题本质原因是由于多个线程对m_Usr等同时写入,如m_szUsrName = authUser,竞争导致的crash。
    可奇怪的是,在写入或赋值前,我们已经加锁了啊!百思不得其解。
     
    问题的解决:
    通过走读代码,发现了一行可疑点:
    boost::mutex::scoped_lock(m_runtimeMutex);
    正常情况下,我们都是这样使用:
    boost::mutex::scoped_lock Lock(m_runtimeMutex);
    即会定义一个临时变量 Lock.
    这2者有何不同呢。如果定义了Lock变量,那么它的作用域为整个函数域,即从{开始,到}结束,这样mutex就起到了保护数据同时写入竞争的作用;
    那么是否没有Lock变量情况下,scoped_lock的作用域仅仅是到该行的“;”就结束了呢?
    为了验证这个想法,我写了如下代码,通过对象何时析构来证实该想法:

    1. #include <stdio.h>  
    2. #include <string>  
    3.   
    4. using namespace std;  
    5.   
    6. class my  
    7. {  
    8.  public:  
    9.   my(const std::string & name)  
    10.   {  
    11.    m_name = name;  
    12.    printf("create [%s]\n", m_name.c_str());  
    13.   }  
    14.     
    15.   virtual ~my()  
    16.   {  
    17.    printf("destroy [%s]\n", m_name.c_str());  
    18.   }  
    19.    
    20.  private:  
    21.   std::string m_name;  
    22. };  
    23.   
    24. int main(int argc, char** argv)  
    25. {  
    26.  my("1");  
    27.    
    28.  my tmp("2");  
    29.    
    30.  printf("function end\n");  
    31.  return 0;  


     

    果不其然,my("1")这个对象在分号;结束之后就进行了析构,而tmp对象直到main函数结束之后才析构。

    boost::lexical_cast,mutex::scoped_lock,bind,function,signal的用法

    (2016-08-08 13:12:49)
      

    c++数据类型万能转换器boost::lexical_cast .

    boost::lexical_cast为数值之间的转换(conversion)提供了一揽子方案,比如:将一个字符串"123"转换成整数123,代码如下:

    1. string s = "123"; 
    2. int a = lexical_cast<<spanclass="datatypes">int>(s); 

    这种方法非常简单,笔者强烈建议大家忘掉std诸多的函数,直接使用boost::lexical_cast。如果转换发生了意外,lexical_cast会抛出一个bad_lexical_cast异常,因此程序中需要对其进行捕捉。

    mutex::scoped_lock

    发现某个函数对共享资源写入前调用的了该函数,但是没发现释放锁的地方,当时就理解为:此锁为智能锁,作l用域应该在函数内,函数调用完毕,锁会自动释放。

    两种的区别,很常见的

    boost::mutex::scoped_lock(m_runtimeMutex);没有临时变量
    定义一个临时变量Lock. boost::mutex::scoped_lockLock(m_runtimeMutex);


    这两个有何区别?不仅仅如此,很多场景都是如此。

    这2者有何不同呢。如果定义了Lock变量,那么它的作用域为整个函数域,即从{开始,到}结束,这样mutex就起到了保护数据同时写入竞争的作用;
    那么是否没有Lock变量情况下,scoped_lock的作用域仅仅是到该行的“;”就结束了呢?

    1. class my    
    2. {    
    3.  public:    
    4.   my(const std::string & name)    
    5.   {    
    6.    m_name = name;    
    7.    printf("create [%s]\n", m_name.c_str());    
    8.   }    
    9.       
    10.   virtual ~my()    
    11.   {    
    12.    printf("destroy [%s]\n", m_name.c_str());    
    13.   }    
    14.      
    15.  private:    
    16.   std::string m_name;    
    17. };    
    18.     
    19. int main(int argc, char** argv)    
    20. {    
    21.  my("1");    
    22.      
    23.  my tmp("2");    
    24.      
    25.  printf("function end\n");    
    26.  return 0;    
    27. }    
    28. 果不其然,my("1")这个对象在分号;结束之后就进行了析构,而tmp对象直到main函数结束之后才析构。


    boost里的bind,function,signal三个组件都是对用函数做参数(其他算法也用函数做参数),对函数的某一项进行操作。

    bind主要是对函数参数的作用。

    function主要是对函数地址的封装。

    signal主要是异步回调。

    用函数做参数时

    1.普通函数需要传递函数地址。

    2.函数对象需要传递一个对象

    3.成员函数需要传递对象,指明所调用的成员函数。如果只有对象则符合规则2.

    展开全文
  • boost::mutex::scoped_lock

    2019-09-28 01:15:00
    在三维重建过程中,...world作为唯一 访问/更新 对象,可以使用boost::mutex::scoped_lock 。 一:boost::mutex::scoped_lock 使用boost进行线程管理简单使用boost::mutex 。 mutex对象本身并不知道它代表什么...

            在三维重建过程中,世界地图 Map &world作为唯一 访问/更新 对象,可以使用boost::mutex::scoped_lock 。


    一:boost::mutex::scoped_lock

            使用boost进行线程管理简单使用boost::mutex 。

            mutex对象本身并不知道它代表什么,它仅仅是被多个消费者线程使用的资源访问的锁定解锁标志。在某个时刻,只有一个线程可以锁定这个mutex对象,这就阻止了同一时刻有多个线程并发访问共享资源。一个mutex就是一个简单的信号机制。

            给mutex加解锁有多种策略,最简单的是使用scoped_lock类,它使用一个mutex参数来构造,并一直锁定这个mutex直到对象被销毁。如果这个正在被构造的mutex已经被别的线程锁定的话,当前线程就会进入wait状态,直到这个锁被解开。


    稍微详细的一点介绍参考:Boost锁~临界区保护和临界资源共享

            mutex锁不分读写,作为智能锁是需要一定的使用代价的。


    一种具体实现参考:mutex、condition、scope_lock的简单实现


    二、读写锁的使用:

           参考:Boost线程库学习笔记 

           文章给出了详细的读写锁 boost::read_write_mutex的使用方法,省去了自己再写解死锁方法的劳动。并且对一些经典锁死现象进行了代码级分析和解决方案提出,课件作者付出了大量的劳动。



    转载于:https://www.cnblogs.com/wishchin/p/9199990.html

    展开全文
  • boost::mutex::scoped_lock lock(video_mutex_); boost的区域锁,用来对线程同步进行资源保护的。 需要注意的是,所保护的区域,要做到应少尽少,更不能在保护区域加入sleep类似的睡眠。在保护区加睡眠时间,并没有...

    boost::mutex::scoped_lock lock(video_mutex_);
    boost的区域锁,用来对线程同步进行资源保护的。
    需要注意的是,所保护的区域,要做到应少尽少,更不能在保护区域加入sleep类似的睡眠。在保护区加睡眠时间,并没有达到睡眠并放弃cpu执行片段的目的,只会拜拜占用资源导致其他地方不能得到及时的执行。

    展开全文
  • boost: Mutex、scoped_lock 使用方式

    千次阅读 2016-03-03 10:15:16
    #include class CBusiness { public:  void Push(int val)  {    boost::mutex::scoped_lock lock(m_ListMutex);  m_List.push_back(val);  }  void Pop()  {
  • boost::recursive_mutex::scoped_lock

    千次阅读 2016-07-28 11:12:49
    这几天帮人调试程序,遇到boost的锁相关问题。 [cpp] view plaincopy #include  #include    boost::mutex mut;... boost::mutex::scoped_lock lock(mut);   std::cout "This is
  • 最近在公司负责一个线程池的模块,里面用到了boost库中的mutex、condition_variable与mutex::scoped_lock,现在将代码拷贝如下: classCondition{ public: Condition():count(0){} virtual~Condition(){} ...
  • 一 std::scoped_lock简介 template< class... MutexTypes > class scoped_lock; (1)将多个锁(std::mutex等)包装成一种锁类型,用于线程一次性申请多个锁,避免死锁。 (2)当程序出现异常,可自动析构...
  • boost的scoped_lock

    千次阅读 2011-12-19 16:34:01
    这几天帮人调试程序,遇到boost的锁相关问题。 #include #include boost::mutex mut; void bar() ... boost::mutex::scoped_lock lock(mut); std::cout !" ; } void foo() { boost::mutex
  • why scoped_lock is recommanded? 其实,这和RAII idiom变流行是一样的原因:因为你可以确保任何情况下离开执行范围都会解锁mutex。 注意,这不仅仅是说你可能忘记调用unlock():并且,在你的mutex被锁定之后,...
  • 考虑互斥量的使用,最基本的代码是: 1 #include <iostream> 2 #include <thread> 3 #include <mutex> ... 7 std::lock_guard<std::mutex> make_lock() { 8 ...
  • boost mutex以及scoped_lock应用

    千次阅读 2017-07-28 18:04:48
    boost::mutex提供了跨平台的锁操作...在本文中仅仅是介绍简单的两种锁,最高效的锁boost::mutex和区域锁boost::mutex::scoped_lockboost::mutex例子#include <boost/thread/mutex.hpp>boost::mutex m_mutexAc...
  • boost多线程之scoped_lock理解

    千次阅读 2016-09-08 15:26:24
    最近突然用到了多线程,就把std::thread和boost::thread的文档都看了看,关于线程对共享区资源的访问,有以下三种访问方式: ... 对于锁,我觉得boost的scope_lock和C++的智能指针有异曲同工之妙,均是巧妙地利用了C++
  • void print_block (int n, char c) { // critical section (exclusive access to std::cout signaled by locking mtx): boost::mutex::scoped_lock lock(mut); for (int i=0; i 执行结果如下: boost::mutex::...
  • (Boost)mutex scoped_lock

    千次阅读 2016-04-02 13:03:23
    mutex_t::scoped_lock lock(mu);   return ++n;   }   operator T(){ return n;} };   int main() {   return 0;     }
  • boost之mutex scoped_lock

    2014-06-13 08:59:00
    mutex_t::scoped_lock lock(mu);   return   ++n;   }   operator T(){ return   n;} };   int   main() {   return   0;     }   一切源于对计算机的热爱
  • 是类似C11的Scoped_lock的功能引起的,即在大括号里加了Scoped_lock的变量,出了大括号会被销毁; 但是不加不行,不加V8的初始化会报错,加了,就必须把初始化和函数调用写到一个方法里,初始化实在太慢了,大约要3秒才能...
  • Scope_Lock(str);//锁定str; ....启动V8引擎代码//这些代码也会用到str; }; void callJsFun(string arg1,string arg2) { callJs("JS函数(arg1,arg2)",str)//需要用到str变量;这一行就会报错,因为str...
  • scoped_lock<interprocess_mutex> lock(data->mutex); if(data->message_in) data->cond_full.wait(lock); if(99 == i) sprintf(data->items, "%s", "last message"); else sprintf(data->items, "%s_%d...
  • 1.对std::auto_ptr进行复制,原来的指针会失效 std::auto_ptr p; std::auto_ptr wptr(new Widget()); p = wptr; // wptr指向失效 p->print();...2.boost::scoped_ptr不能拷贝 ...boost::scoped_p
  • 文章目录1.boost智能指针2.scoped_ptr3.shared_ptr3.waek_ptr4.scoped_array/shared_array5.PIMPL技法 1.boost智能指针 智能指针是利用RAII(Resource Acquisition Is Initialization:资源获取即初始化)来管理...
  • 1. std::defer_lock_t 、 std::try_to_lock_t 和 std::adopt_lock_t 是用于为 std::lock_guard(C++11) 、 std::scoped_lock(C++14) 、 std::unique_lock(C++11) 和 std::shared_lock(C++17) 指定锁定策略的空结构体...
  • Boost智能指针:scoped_ptr shared_ptr weak_ptr 一. scoped_ptr boost::scoped_ptr和std::auto_ptr非常类似,是一个简单的智能指针,它能够保证在离开作用域后对象被自动释放。下列代码演示了该指针的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,455
精华内容 2,182
关键字:

scoped_lock