C++线程安全

c++多线程编程安全性简单说明

对于多线程编程，很多人概念不清，写代码的时候要么是处处加锁，影响性能不说，还容易莫名其妙的死锁，还有人对多线程敬而远之。

所以 学习多线程编程最重要的不是学习API,而是理解什么才是多线程安全的代码

从例子说起

#include  < windows.h >
#include  < process.h >

long  global1  =   0 ;
volatile   long  global2  =   0 ;

class  MyClass
{
public :
     MyClass() : m( 0 )
     {
         ++ m;
     }

     int  fun( int  v)
     {
         return  m + v;  // -----------9
     }

     void   set ( int  v)
     {
         m  =  v;    // -------------10
     }
     int  m;
};

MyClass global_object;  // -------------8

unsigned  int  __stdcall thread_fun1( void   * param)
{
     static   int  static2  =   0 ;
     static  MyClass static_object;  // --------6
     int  local1  =   0 ;
    
     ++ local1;      // -------1
     ++ static2;     // -------2
     ++ global1;     // -------3
     ++ global2;     // -------4
     InterlockedIncrement( & global1);  // --------5

     local1  =  global_object.fun(local1);  // ----------7

     global_object. set (local1);  // ---------------11

     return   0 ;
}


unsigned  int  __stdcall thread_fun2( void   * param)
{
     ++ global1;     // -------3
     ++ global2;     // -------4
     InterlockedIncrement( & global1);  // --------5

     global_object. set ( 1 );  // -----------11
     return   0 ;
}


int  main()
{
     HANDLE thread1  =  (HANDLE)_beginthreadex( 0 , 0 , & thread_fun1, 0 , 0 , 0 );  // thread 1
     HANDLE thread2  =  (HANDLE)_beginthreadex( 0 , 0 , & thread_fun1, 0 , 0 , 0 );  // thread 2
     HANDLE thread3  =  (HANDLE)_beginthreadex( 0 , 0 , & thread_fun2, 0 , 0 , 0 );  // thread 3
    
     WaitForSingleObject(thread1,INFINITE);
     WaitForSingleObject(thread2,INFINITE);
     WaitForSingleObject(thread3,INFINITE);
    
     return   0 ;
}

1.局部变量局部使用是安全的
为什么?因为每个thread 都有自己的运行堆栈，而局部变量是生存在堆栈中,大家不干扰。
所以代码1
int local1;
++local1;
是安全的

2.全局原生变量多线程读写是不安全的
全局变量是在堆(heap)中
long global1 = 0;
++global2;
++这个操作其实分为两部，一个是读，另外一个是写
mov         ecx,global
add         ecx,1
mov         global,ecx
所以代码3处是不安全的

3.函数静态变量多线程读写也是不安全的
道理同2
所以代码2处也是不安全的

4.volatile能保证全局整形变量是多线程安全的么
不能。
volatile仅仅是告诫compiler不要对这个变量作优化，每次都要从memory取数值，而不是从register
所以代码4也不是安全

5.InterlockedIncrement保证整型变量自增的原子性
所以代码5是安全的

6.function static object的初始化是多线程安全的么
不是。
著名的Meyer Singleton其实不是线程安全的
Object & getInstance()
{ 
     static Object o;
     return o;
}
可能会造成多次初始化对象
所以代码6处是不安全的

7.在32机器上，4字节整形一次assign是原子的
比如
i =10; //thread1
i=4; //thread2
不会导致i的值处于未知状态,要么是10要么是4

其它的大家自己去体会。

写好多线程安全的法宝就是封装，使数据有保护的被访问到
安全性：
局部变量>成员变量>全局变