Posted on 2006-03-22 10:33
高山流水 阅读(692)
评论(0) 编辑 收藏 引用 所属分类:
程序语言
对于多线程编程，很多人概念不清，写代码的时候要么是处处加锁，影响性能不说，还容易莫名其妙的死锁，还有人对多线程敬而远之。
所以学习多线程编程最重要的不是学习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
其它的大家自己去体会。
写好多线程安全的法宝就是封装，使数据有保护的被访问到
安全性：
局部变量>成员变量>全局变量
Feedback
# re: 什么才是多线程安全的 回复
2006-01-18 08:06 by
关于栈和堆的问题，并不一定在堆上的都是不安全的。
type struct _abc
{
int a;
int b;
int c;
}abc, *pabc;
abc myabc;
pabc pmyabc = new myabc;
两个变量myabc和pmyabc的对象所在就完全不同，使用new会在堆栈上分配，而直接声明变量会在堆上分配。堆比较小，而栈大，对于一些比较庞大的类对象，一般都要在堆栈上分配，但是堆栈的性能逊于堆的性能，小对象例如int阿什么的都是直接在堆上生成。每个线程有自己的独立的堆和栈。全局变量在公共堆上生成，所以不安全。而对线程独立的堆和栈，都是线程安全，互不相干的。
操作线程尽量使用EnterCriticalSection和LeaveCriticalSection，性能要比Mutex强，尤其是大量锁定和解锁尤为明显。
# to:nanami 回复
2006-01-18 10:09 by
先澄清一下名词
堆:heap
栈(堆栈):stack
我没说在heap上面都是不安全的阿
其实不管在stack还是heap，说到底也不果是一个普通的内存地址，没特殊的地方，只要是多个thread不加锁的读写都会引起性能问题。
# re: 什么才是多线程安全的 回复
2006-01-18 14:43 by
to nanami：
一些问题，与你商榷，从你的发言看，对于堆和栈你恰恰搞反了，你提到
“使用new会在堆栈上分配”
——确切的说是堆（heap）上（当然重载new的行为者不一定）
“而直接声明变量会在堆上分配”
——全局域（如任何函数、类外定义的变量）和静态变量（如有static指示符的）分配（确切的说是映射）在静态存储区（大致可以认为和可执行代码运行时内存区域相当），动态分配发生在堆（heap）上（前提是没有重载new等分配操作符），局部变量在栈（stack）上分配
“堆比较小，而栈大”
——这么说有点没谱，大小不是堆和栈的区别，一般而言栈大小确定，栈一旦建立大小就固定了，因此会发生溢出，而堆则可以随时向操作系统申请更多，
“对于一些比较庞大的类对象，一般都要在堆栈上分配”
——由上一点可知，应该是“对于一些比较庞大的类对象，一般都要在堆而不是在栈上分配”
“堆栈的性能逊于堆的性能，小对象例如int阿什么的都是直接在堆上生成”
——本质上没什么性能差异，最多也就是由于堆上的内存总是只能通过指针和引用来访问，需要多做一次内存寻址而已
“每个线程有自己的独立的堆和栈。全局变量在公共堆上生成，所以不安全。而对线程独立的堆和栈，都是线程安全，互不相干的。”
——安全不安全全看该对象是否是“临界资源”（参看操作系统书籍），而不论是在哪里分配的，小明兄的一句话至为妥当：“其实不管在stack还是heap，说到底也不果是一个普通的内存地址，没特殊的地方，只要是多个thread不加锁的读写都会引起性能问题。”，当然小明兄所指“性能问题”肯定是笔误，我想他指的是“安全问题”
# re: 什么才是多线程安全的 回复
2006-01-21 15:05 by
同意楼上说的！
# re: 什么才是多线程安全的 回复
2006-02-27 11:27 by
nanami
你什么都说反了,我真是汗你的基础啊.....
# re: 什么才是多线程安全的 回复
2006-03-02 23:19 by
2006-01-18 14:43 by vender
说的基本完全正确（这句话语意有问题哈～）
# re: 什么才是多线程安全的 回复
2006-03-04 20:18 by
2.全局原生变量多线程读写也不一定是不安全的，只要把代码改成这个样子就安全了
假设 struct T
T* global_t;
线程代码这样
T* nt = new T;
T* temp = & global_t;
do{
memcpy(nt, global_t, sizeof(T));
//修改
}while(!CAS(&global_t, temp, nt));
CAS 可以用 xchgcmp 指令来实现