看《链接装载与库》关于多线程中“过度优化”一节的困惑，烦请指点

书中举了一个很简单的例子:

int global_x = 0; // 两个线程共享的全局变量.

Thread1: // 线程 1 的定义                              Thread2: // 线程 2 的定义

lock();                                                lock();

global_x++;                                          global_x++;

unlock();                                             unlock();

看上去，因为线程 1 和线程 2 在访问 global_x 时都使用了 lock() 和 unlock() 保护,因此 global_x++ 的行为不会被并发破坏，所以在线程 1 和线程 2 结束之后，global_x 的值似乎一定是 2。但其实，这么理所当然的猜测有可能是错误的。解释如下:

[Thread1] 读 global_x 值到寄存器 R[1]
[Thread1] R[1]++ (R[1]=1)
[Thread2] 读 global_x 值到寄存器 R[2]
[Thread2] R[2]++ (R[2]=1)
[Thread2] 将寄存器 R[2]的值写回 global_x (global_x=1)
[Thread1] 将寄存器 R[1]的值写回 global_x (global_x=1)

出现这样的问题，是因为编译器为了提高global_x的访问速度，将global_x的值放到了某个寄存器里，这就导致了所谓过度优化的问题。

书中给出的为了阻止过度优化的方法是使用 volatile 关键字。（注：这里的 volatile 仅指 C/C++的关键字，不要和 java 中的搞混）

我的理解是volatile从来不是多线程中需要的，靠操作系统提供的同步原语应该就足够了。

https://stackoverflow.com/questions/78172/using-c-pthreads-do-shared-variables-need-to-be-volatile#answer-784840

https://stackoverflow.com/questions/3208060/does-guarding-a-variable-with-a-pthread-mutex-guarantee-its-also-not-cached

pthread locks implement memory barriers that will ensure that cache effects are made visible to other threads. You don't need volatile to properly deal with the shared variable i if the accesses to the shared variable are protected by pthread mutexes.

wevsty

2019-12-24 00:59:22 +08:00

就楼主举的这个例子来说，我认为没有 volatile 编译器也会正确的进行优化，不会导致计数结果出现错误。

原因是在这个代码的函数中没有做除了++以外的操作，++操作也要求一定要同步修改到内存，并没有什么必要需要把操作数保存到寄存器里来预先载入。
从汇编的角度来看，编译器转化为 ASM 的伪代码应该类似于:
```
call lock()
mov <reg>,<mem>
inc <reg>
mov <mem>,<reg>
call unlock()
```
甚至更简单一些直接化简为：
```
call lock()
inc <mem>
call unlock()
```
为了保持语义正确，这已经是最简化的代码了，没有什么优化的空间。
对于单纯写入内存的操作，操作系统提供的同步语义已经能提供足够的保护了。

但 volatile 也并非在多线程开发中没有意义，举个例子：
```
int global_x = 0;

void thread_01()
{
while(global_x < 100)
{
sleep(1);
}
}

void thread_02()
{
lock();
global_x++;
unlock();
}
```
当 thread_01 执行的时候，thread_01 内部并没有对 thread_01 做任何修改，这时候编译器无法预测到 global_x 可能被改变，所以优化的时候很有可能会把 global_x 放到寄存器来加速循环的执行。
这种时候即使 thread_02 里对 global_x 操作的时候加了锁，最终 thread_01 还是可能会陷入死循环。

volatile 关键字代表强制要求编译器每一次使用这个变量的时候都必须从内存读取，所以在这个例子中，使用 volatile 后就可以避免死循环的出现。

所以通常的，对于可能被读取线程以外的什么条件或者代码改动的变量应该使用 volatile 关键字才不容易出现问题。