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

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


写好多线程安全的法宝就是封装,使数据有保护的被访问到
安全性:
局部变量>成员变量>全局变量
Posted on 2006-11-30 16:11 艾凡赫 阅读(3013) 评论(4)  编辑 收藏 引用 所属分类: 多线程C++

Feedback

# re: 什么代码才是线程安全的  回复  更多评论   

2008-02-25 16:28 by badboyfind
请问:您对
function static object的初始化是多线程安全的么
不是。
著名的Meyer Singleton其实不是线程安全的
Object & getInstance()
{
static Object o;
return o;
}
可能会造成多次初始化对象
所以代码6处是不安全的

认识深刻吗?
对于Meyer Singleton,你有没有实际监测过,我只是通过<Effective C++>中条款3了解到Meyer Singleton。可是对于上面的“可能造成多次初始化对象”,能不能做更加详细的阐述,可不可以进一步举例示范?

可以回复我的邮箱: sincere_listen@163.com
急需知道答案!

# re: 什么代码才是线程安全的  回复  更多评论   

2008-02-25 17:45 by 爱饭盒
MyClass() : m(0)
{
++m;
}
问题出在这里;

上面又说:
++这个操作其实分为两部,一个是读,另外一个是写
mov ecx,global
add ecx,1
mov global,ecx
当为多线程时,MyClass构造函数可能会被调用多次:举个例子


class MyClass2
{
public:
MyClass2()
{
m++;
//如果去掉sleep,则第二次调用函数func()时不会再进入构造函数,所以要线程安全,要防止代码同时进入这里.
sleep(10);
cout<<"MyClass2:"<<m<<endl;
}
int m;
void func(){ cout<< "func:"<<m<<endl;}
};
void func()
{
static MyClass2 o2;
o2.func();
}
int main()
{
func();
cout<<"################"<<endl;
func();
return 0;
}

# re: 什么代码才是线程安全的  回复  更多评论   

2008-02-25 17:51 by 爱饭盒
这里对同时进入一段代码使用sleep()进行放大处理,实际应用时,单单一个++m,也可能会同时多个线程访问.只是++m不太好测试.

# re: 什么代码才是线程安全的  回复  更多评论   

2008-02-25 18:03 by 爱饭盒
呵呵,刚才代码贴的不对,多线程的没贴出来,在多线程时能体现出来这点,单线程体现不出来.

只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理