c++ - (C/C++) 为什么使用全局变量同步单个读取器和单个写入器是有效的？

Question

假设有一个像 std::vector 这样的数据结构和一个初始化为零的全局变量 intsyncToken。另外，恰好有两个线程作为读取器/写入器，为什么以下(伪)代码(in)有效？

void reader_thread(){
    while(1){
        if(syncToken!=0){
            while(the_vector.length()>0){
                 // ... process the std::vector 
            }
            syncToken = 0;  // let the writer do it's work
        }
        sleep(1);
    }
}

void writer_thread(){
    while(1){
        std::string data = waitAndReadDataFromSomeResource(the_resource);
        if(syncToken==0){
            the_vector.push(data);
            syncToken = 1;  // would syncToken++; be a difference here?
        }
        // drop data in case we couldn't write to the vector
    }
}

虽然这段代码的(时间)效率不高，但据我所知，该代码是有效的，因为两个线程仅以不会导致未定义行为的方式同步全局变量值。唯一的问题可能发生在同时使用 vector 时，但这不应该发生，因为仅在零和一之间切换作为同步值，对吗？

更新由于我犯了只问是/否问题的错误，因此我将问题更新为“为什么”，希望得到一个非常具体的案例作为答案。似乎问题本身根据答案绘制了错误的图片，因此我将详细说明上面代码中我的问题/疑问。

首先，我想指出，我要求提供一个特定的用例/示例/证明/详细解释，以准确说明不同步的情况。即使是让示例计数器表现出非单调递增的 C 示例代码也只会回答是/否问题，而不是为什么!我感兴趣的是为什么。因此，如果您提供一个示例来证明它存在问题，我会对原因感兴趣。

根据(我的)定义，当且仅当 if 语句中的代码(不包括 if block 底部的syncToken 赋值)只能由这两个给定线程之一执行时，上述代码才应命名为同步。给定时间。

基于这个想法，我正在寻找一个可能基于汇编程序的示例，其中两个线程同时执行 if block - 意味着它们不同步或不同步。

作为引用，我们看一下 gcc 生成的汇编代码的相关部分:

; just the declaration of an integer global variable on a 64bit cpu initialized to zero
syncToken:
.zero   4
.text
.globl  main
.type   main, @function

; writer (Cpu/Thread B): if syncToken == 0, jump not equal to label .L1
movl    syncToken(%rip), %eax
testl   %eax, %eax
jne .L1

; reader (Cpu/Thread A): if syncToken != 0, jump to Label L2
movl    syncToken(%rip), %eax
testl   %eax, %eax
je  .L2

; set syncToken to be zero
movl    $0, syncToken(%rip)

现在我的问题是，我不明白为什么这些指令会不同步。

假设两个线程都在自己的 CPU 核心上运行，例如线程 A 在核心 A 上运行，线程 B 在核心 B 上运行。初始化是全局的，并且在两个线程开始执行之前完成，因此我们可以忽略初始化并假设两个线程都启动与syncToken=0；

示例:

1. CPU A:movlsyncToken(%rip)，%eax
2. CPU A:上下文切换(保存所有寄存器)
3. CPU B:movlsyncToken(%rip)，%eax
4. CPU B:teSTL %eax，%eax
5. CPU B: jne .L1 ;这个是 false => 如果阻塞则执行 writer
6. CPU B:上下文切换
7. CPU A:上下文切换到线程(恢复所有寄存器)
8. CPU A:teSTL %eax，%eax
9. CPU A: je .L2 ;这是 false => 不执行 if block

老实说，我构建了一个运行良好的示例，但它表明我看不出为什么变量应该不同步，以便两个线程同时执行 if block 。我的观点是:虽然上下文切换会导致 %eax 与 RAM 中的syncToken的实际值不一致，但代码应该做正确的事情，如果它不是唯一允许运行的线程，则不执行 if block 它。

更新2可以假设syncToken只会像所示的代码中那样使用。不允许其他函数(如 waitAndReadDataFromSomeResource)以任何方式使用它

更新3让我们更进一步，提出一个稍微不同的问题:是否可以使用 intsyncToken 同步两个线程、一个读取器、一个写入器，以便线程不会通过同时执行 if block 而始终不同步？如果是的话 - 那很有趣^^如果不是 - 为什么？

Answer 1

基本问题是您假设对 syncToken 的更新与对 vector 的更新是原子的，但事实并非如此。

无法保证在多核 CPU 上这两个线程不会在不同的核心上运行。并且无法保证内存更新写入主内存或缓存从主内存刷新的顺序。

因此，当在读取线程中将 syncToken 设置为零时，写入线程可能会在看到 vector 内存的更改之前看到该更改。因此它可以开始将内容推送到 vector 的过时末尾。

类似地，当您在编写器线程中设置 token 时，读取器可能会开始访问 vector 内容的旧版本。更有趣的是，根据 vector 的实现方式，读者可能会看到 vector header 包含指向内存内容的旧指针

void reader_thread(){
    while(1){
        if(syncToken!=0){
            while(the_vector.length()>0){
                 // ... process the std::vector 
            }
            syncToken = 0;  // let the writer do it's work
        }
        sleep(1);

此 sleep 将在进入操作系统时导致内存刷新，但无法保证内存刷新的顺序或编写器线程将按照哪个顺序看到它。

    }
}

void writer_thread(){
    while(1){
        std::string data = waitAndReadDataFromSomeResource(the_resource);

这可能导致内存刷新。另一方面也可能不会。

        if(syncToken==0){
            the_vector.push(data);
            syncToken = 1;  // would syncToken++; be a difference here?
        }
        // drop data in case we couldn't write to the vector
    }
}

使用 syncToken++ (一般来说)没有帮助，因为它执行读/修改/写操作，因此如果另一端碰巧同时进行修改，您可能会得到任何某种结果。

为了安全起见，您需要使用内存同步或锁来确保内存以正确的顺序读取/写入。

在此代码中，您需要在读取 syncToken 之前使用读同步屏障，并在写入之前使用写同步屏障。

使用写同步可确保在之后的任何更新之前，到该点的所有内存更新对主内存都是可见的 - 以便在 syncToken 之前正确更新 the_vector设置为一。

在读取syncToken之前使用读取同步将确保缓存中的内容与主内存是正确的。

一般来说，这可能相当棘手，除非性能非常关键，否则最好使用互斥体或信号量来确保同步。

正如 Anders 所指出的，编译器仍然可以自由地重新排序对 syncToken 的访问和对 the_vector 的访问(如果它可以确定这些函数的作用，则可以使用std::vector 它可能可以) - 添加内存屏障将停止这种重新排序。将 syncToken 设为 volatile 也会停止重新排序，但它不会解决多核系统上的内存一致性问题，并且不允许您安全地对同一系统进行读取/修改/写入来自 2 个线程的变量。