scoped_lock

一个由于锁的作用域导致core dump的问题的解决

请看如下代码：

[cpp] view plain copy

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的作用域仅仅是到该行的“;”就结束了呢？
为了验证这个想法，我写了如下代码，通过对象何时析构来证实该想法：

[cpp] view plain copy

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;  
32. } 
    

 

果不其然，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函数结束之后才析构。

参考链接： http://blog.csdn.net/acs713/article/details/24290659

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

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

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

signal主要是异步回调。

用函数做参数时

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

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

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