memory barrier 和 volatile 是否足以避免数据竞争？

Question

我想看看我是否被迫使用原子整数。

我有一个看起来与此类似的循环：

struct loop {
  volatile int loop_variable;
  volatile int limit;
}

for (int i = loop.loop_variable ; i < loop.limit ; loop.loop_variable++) {

}

然后另一个 thead 这样做：

loops.loop_variable = loops.limit;

并发出 memory 屏障。

这个多线程安全吗？

存在数据竞争的程序集在这些行之间：

// loop.loop_variable = loop.limit;
movl    4+loop.0(%rip), %eax                                                                                                                                                             
movl    %eax, loop.0(%rip)  

和

    // for (int i = loop.loop_variable ; i < loop.limit ; loop.loop_variable++)
    movl    loop.0(%rip), %eax                                                                                                                                                               
    movl    %eax, -4(%rbp)                                                                                                                                                                   
    jmp .L2                                                                                                                                                                                  
.L3:                                                                                                                                                                                         
    movl    loop.0(%rip), %eax                                                                                                                                                               
    addl    $1, %eax                                                                                                                                                                         
    movl    %eax, loop.0(%rip)                                                                                                                                                               
.L2:                                                                                                                                                                                         
    movl    loop.0(%rip), %eax                                                                                                                                                               
    cmpl    $99999, %eax                                                                                                                                                                     
    jle .L3                                                                                                                                                                                  
    movl    $0, %eax  

之间可能存在数据竞争

movl    loop.0(%rip), %eax                                                                                                                                                               
        addl    $1, %eax                                                                                                                                                                         
        movl    %eax, loop.0(%rip)

因为它是增加 loop_variable 的三个指令。 但只有一个将循环变量覆盖到极限。

Answer 1

这个多线程安全吗？

不。

鉴于

loops[0].loop_variable = loops[0].limit;
< memory barrier >

在一个线程中，memory 屏障不会阻止int i = loop.loop_variable读取不确定值或loop.loop_variable++在另一个线程中产生无意义的结果。 其他线程仍然可能“看到”对loops[0].loop_variable的更改。 或部分改变。

memory 障碍只是在事后强加一致性——它事先没有做任何事情。