Skip to main content
 首页 » 编程设计

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

2024年02月20日9zhujiabin

假设有一个像 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 而始终不同步?如果是的话 - 那很有趣^^ 如果不是 - 为什么?

请您参考如下方法:

基本问题是您假设对 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 个线程的变量。