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

其它的大家自己去體會。

寫好多線程安全的法寶就是封裝，使數據有保護的被訪問到
安全性：
局部變量>成員變量>全局變