什么才是多线程安全的

 

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

所以学习多线程编程最重要的不是学习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

其它的大家自己去体会。

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

**************************************************************************************************************

附：

关于栈和堆的问题，并不一定在堆上的都是不安全的。
type struct _abc
{
int a;
int b;
int c;
}abc, *pabc;

abc myabc;
pabc pmyabc = new myabc;

两个变量myabc和pmyabc的对象所在就完全不同，使用new会在堆栈上分配，而直接声明变量会在堆上分配。堆比较小，而栈大，对于一些比较庞大的类对象，一般都要在堆栈上分配，但是堆栈的性能逊于堆的性能，小对象例如int阿什么的都是直接在堆上生成。每个线程有自己的独立的堆和栈。全局变量在公共堆上生成，所以不安全。而对线程独立的堆和栈，都是线程安全，互不相干的。

操作线程尽量使用EnterCriticalSection和LeaveCriticalSection，性能要比Mutex强，尤其是大量锁定和解锁尤为明显。

 

一些问题，与你商榷，从你的发言看，对于堆和栈你恰恰搞反了，你提到

“使用new会在堆栈上分配”
——确切的说是堆（heap）上（当然重载new的行为者不一定）

“而直接声明变量会在堆上分配”
——全局域（如任何函数、类外定义的变量）和静态变量（如有static指示符的）分配（确切的说是映射）在静态存储区（大致可以认为和可执行代码运行时内存区域相当），动态分配发生在堆（heap）上（前提是没有重载new等分配操作符），局部变量在栈（stack）上分配

“堆比较小，而栈大”
——这么说有点没谱，大小不是堆和栈的区别，一般而言栈大小确定，栈一旦建立大小就固定了，因此会发生溢出，而堆则可以随时向操作系统申请更多，

“对于一些比较庞大的类对象，一般都要在堆栈上分配”
——由上一点可知，应该是“对于一些比较庞大的类对象，一般都要在堆而不是在栈上分配”

“堆栈的性能逊于堆的性能，小对象例如int阿什么的都是直接在堆上生成”
——本质上没什么性能差异，最多也就是由于堆上的内存总是只能通过指针和引用来访问，需要多做一次内存寻址而已

“每个线程有自己的独立的堆和栈。全局变量在公共堆上生成，所以不安全。而对线程独立的堆和栈，都是线程安全，互不相干的。”
——安全不安全全看该对象是否是“临界资源”（参看操作系统书籍），而不论是在哪里分配的，小明兄的一句话至为妥当：“其实不管在stack还是heap，说到底也不果是一个普通的内存地址，没特殊的地方，只要是多个thread不加锁的读写都会引起性能问题。”，当然小明兄所指“性能问题”肯定是笔误，我想他指的是“安全问题”