局部静态变量是如何做到只初始化一次的?

时间:2022-06-27 19:43:24

局部静态变量是如何做到只初始化一次的?

关于编译选项 -Wa,-adlhn参考

http://blog.csdn.net/lanxinju/article/details/5900986

 

 

以下内容来自于内网别的高人的回复

可以写个程序测试一下: 

12345678910111213141516171819 class A{public:    A() {}public:    int a;}; int static_var_func(){    static A a;    return a.a++;} int main(int argc,char * argv[]){    static_var_func();    return 0;

看看汇编

1 g++
-c -g -Wa,-adlhn yy.cpp

结果: 

12345678910111213141516171819202122232425262728293031323334353637383940414243444546 10:yy.cpp       
****
int static_var_func()
35                           
.loc 1 10 0
36
0000 55                    pushq   %rbp
37                   
.LCFI2:
38
0001 4889E5                movq    %rsp, %rbp
39                   
.LCFI3:
40                   
.LBB2:
11:yy.cpp       
**** {
12:yy.cpp       
****    
static A a;
41                           
.loc 1 12 0
42
0004 B8000000              movl    $_ZGVZ15static_var_funcvE1a, %eax
42     
00
43
0009 0FB600                movzbl  (%rax), %eax
44
000c 84C0                  testb   %al, %al
45
000e 7527                  jne     .L4
46
0010 BF000000              movl    $_ZGVZ15static_var_funcvE1a, %edi
46     
00
47
0015 E8000000              call    __cxa_guard_acquire
47     
00
48
001a 85C0                  testl   %eax, %eax
49
001c 0F95C0                setne   %al
50
001f 84C0                  testb   %al, %al
51
0021 7414                  je      .L4
52
0023 BF000000              movl    $_ZZ15static_var_funcvE1a, %edi
52     
00
53
0028 E8000000              call    _ZN1AC1Ev
53     
00
54
002d BF000000              movl    $_ZGVZ15static_var_funcvE1a, %edi
54     
00
55
0032 E8000000              call    __cxa_guard_release
55     
00
56                   
.L4:
13:yy.cpp       
****    
return a.a++;
57                           
.loc 1 13 0
58
0037 8B050000              movl    _ZZ15static_var_funcvE1a(%rip), %eax
58     
0000
59
003d 89C2                  movl    %eax, %edx
60
003f 83C001                addl    $1, %eax
61
0042 89050000              movl    %eax, _ZZ15static_var_funcvE1a(%rip)
61     
0000
62
0048 89D0                  movl    %edx, %eax
63                   
.LBE2:
14:yy.cpp       
**** }
64                           
.loc 1 14 0
65
004a C9                    leave
66
004b C3                    ret

 亮点就在__cxa_guard_acquire和__cxa_guard_release上,这两个函数实现于libstdc++。大意是一个全局的mutex和一个cond来保护一个锁变量(_ZGVZ15static_var_funcvE1a),锁变量再来保护目标变量(_ZZ15static_var_funcvE1a)。锁变量的第一个字节(也就是%al)表示目标变量是否被初始化过了,第二个字节表示目标变量是否在初始化中。__cxa_guard_acquire的时候将锁变量的第二个字节置1,表示初始化中;如果已经为1了,就等待它变0(通过全局cond)再返回(保证初始化结束)。__cxa_guard_release的时候清除第二个字节,再将第一个字节置1。

 简单地说,g++在变量初始化的前后,自动加了锁保护代码。

 另外还有一种可能的情况,变量初始化的时候,如果存在自引用,可能会循环初始化产生死锁。g++对这种情况也有考虑。

 

http://www.dutor.net/index.php/2013/06/initialization-of-local-static-variables/

  不必说静态变量和普通变量的区别,也不必说静态变量及其作用域的得与失,单单说一下函数作用域的静态变量是如何初始化的。

1
2
3
4
5
6
int foo()
{
static int n = init();
//~ do anything/nothing on 'n'
return n;
}

  在 foo() 第一次被调用时,foo()::s 只初始化一次(C 中,静态变量只允许以常量初始化)。“只初始化一次”是如何保证的呢?当然需要编译器维护一个状态,来标识该变量是否已被初始化,并安插代码,在每一次函数被调用时进行判断。咱们通过汇编验证一把:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
.globl _Z3foov
.type _Z3foov, @function
_Z3foov:
.LFB1405:
pushq %rbp
.LCFI13:
movq %rsp, %rbp
.LCFI14:
movl $_ZGVZ3foovE1n, %eax
movzbl (%rax), %eax
testb %al, %al
jne .L18
movl $_ZGVZ3foovE1n, %edi
call __cxa_guard_acquire
testl %eax, %eax
setne %al
testb %al, %al
je .L18
call _Z4initv
movl %eax, _ZZ3foovE1n(%rip)
movl $_ZGVZ3foovE1n, %edi
call __cxa_guard_release
.L18:
movl _ZZ3foovE1n(%rip), %eax
leave
ret

  寄存器、指令和标号不提,其他符号是什么含义呢?通过 c++filt 进行 demangling,_ZGVZ3foovE1n 标识 ‘guard variable for foo()::n’,作为前面提到的“初始化状态标识”用(低字节),_ZZ3foovE1n 标识 ‘foo()::n’,_Z4initv 即 init()。
  那 __cxa_guard_acquire 和 __cxa_guard_release 呢?故名思议,这两个函数具有锁语义。为什么需要锁呢?当然是基于静态变量的线程安全考虑了。静态变量的状态变化属于业务逻辑,编译器管不着也管不了,但静态变量的初始化过程由编译器负责,在初始化线程安全的问题上还是可以出把力的。
  分析上述汇编代码。首先获取 guard 变量,判断低字节是否为 0,若非零,表示已经初始化,可以直接使用。否则,将 guard 作为参数调用 __cxa_guard_acquire,如果锁成功,调用 init() 初始化静态变量 foo()::n,然后释放锁。如果锁失败,说明产生竞态条件,则会阻塞当前线程,不同于普通锁的地方在于,__cxa_guard_acquire 是有返回值的(当然 pthread_lock 也有返回值,但用途不同),如果发生了等待,__cxa_guard_acquire 返回 0,并不会进入 foo()::n 的初始化过程(其他线程已经初始化过了,初始化失败的情况就不细究了)。
  为了验证上述分析,可以将 init() 实现成一个耗时的操作,令多个线程“同时”调用 foo(),然后查看各个线程的运行状态。
  利用该机制,可以很好的实现所谓 Singleton 模式:

1
2
3
4
5
Singleton* Singleton::GetInstance()
{
static Singleton instance;
return &instance;
}

  对于单线程程序,静态变量的保护是没有必要的,g++ 的 -fno-threadsafe-statics 选项可以禁掉该机制。