如果两个线程读取 & 会发生什么？写入同一块内存

Question

我的理解是，如果两个线程正在从同一块内存中读取数据，并且没有线程正在写入该内存，则该操作是安全的。但是，我不确定如果一个线程正在读取而另一个线程正在写入会发生什么。会发生什么？结果未定义吗？或者读的内容会变得陈旧吗？如果过时的读取不是问题，是否可以对变量进行不同步的读写？或者是否有可能数据会被损坏，并且读取和写入都不正确，并且在这种情况下应该始终同步？

我想说的是，我已经了解到这是后一种情况，内存访问的竞争使状态未定义......但我不记得我可能在哪里了解到这一点，并且我很难找到在谷歌上回答。我的直觉是，变量在寄存器中进行操作，并且真正的（如在硬件中）并发是不可能的（或者是），因此可能发生的最糟糕的情况是陈旧的数据，即以下情况

WriteThread: copy value from memory to register
WriteThread: update value in register
ReadThread:  copy value of memory to register
WriteThread: write new value to memory

：有陈旧的数据。

Answer 1

通常，内存以由 CPU 架构确定的原子单元进行读取或写入（32 位和 64 位项目在 32 位和 64 位边界上对齐现在很常见）。

在这种情况下，会发生什么取决于写入的数据量。

让我们考虑 32 位原子读/写单元的情况。

如果两个线程将 32 位写入这样一个对齐的单元中，那么发生的情况绝对是明确的：保留两个写入值之一。不幸的是，对于您（好吧，程序）来说，您不知道哪个值。通过极其聪明的编程，您实际上可以使用这种读取和写入的原子性来构建同步算法（例如，Dekker's算法），但通常使用架构定义的锁会更快。

如果两个线程写入的内容多于一个原子单元（例如，它们都写入一个 128 位值），那么实际上写入的值的原子单元大小的片段将以绝对明确定义的方式存储，但是您不会知道哪个值的哪些部分是以什么顺序写入的。因此，最终可能存储在存储中的是来自第一个线程、第二个线程的值，或者来自两个线程的原子单元大小的位的混合。

类似的想法适用于以原子单位或更大单位进行的一个线程读取和一个线程写入。

基本上，您不想对内存位置进行不同步的读取和写入，因为您不会知道结果，即使架构可能很好地定义了结果。

Answer 2

结果是未定义的。数据损坏是完全有可能的。举一个明显的例子，考虑由 32 位处理器操作的 64 位值。假设该值是一个简单的计数器，当低 32 位包含 0xffffffff 时，我们将其递增。增量产生 0x00000000。当我们检测到这一点时，我们会增加上面的单词。然而，如果其他线程在低位字递增和高位字递增之间读取该值，它们会得到一个高位字未递增的值，但低位字设置为 0——这是一个完全不同的值与增量完成之前或的情况不同。

Answer 3

正如我在中暗示的那样Ira Baxter 的回答是，CPU 缓存在多核系统中也发挥着作用。考虑以下测试代码：

危险将罗宾逊！

以下代码将优先级提高到实时，以实现更一致的结果 - 虽然这样做需要管理员权限，但如果在双核或单核系统上运行代码要小心，因为您的计算机将在测试运行期间锁定。

#include <windows.h>
#include <stdio.h>

const int RUNFOR = 5000;
volatile bool terminating = false;
volatile int value;

static DWORD WINAPI CountErrors(LPVOID parm)
{
    int errors = 0;
    while(!terminating)
    {
        value = (int) parm;
        if(value != (int) parm)
            errors++;
    }
    printf("\tThread %08X: %d errors\n", parm, errors);
    return 0;
}

static void RunTest(int affinity1, int affinity2)
{
    terminating = false;
    DWORD dummy;
    HANDLE t1 = CreateThread(0, 0, CountErrors, (void*)0x1000, CREATE_SUSPENDED, &dummy);
    HANDLE t2 = CreateThread(0, 0, CountErrors, (void*)0x2000, CREATE_SUSPENDED, &dummy);

    SetThreadAffinityMask(t1, affinity1);
    SetThreadAffinityMask(t2, affinity2);
    ResumeThread(t1);
    ResumeThread(t2);

    printf("Running test for %d milliseconds with affinity %d and %d\n", RUNFOR, affinity1, affinity2);
    Sleep(RUNFOR);
    terminating = true;
    Sleep(100); // let threads have a chance of picking up the "terminating" flag.
}

int main()
{
    SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
    RunTest(1, 2);      // core 1 & 2
    RunTest(1, 4);      // core 1 & 3
    RunTest(4, 8);      // core 3 & 4
    RunTest(1, 8);      // core 1 & 4
}

在我的四核 intel Q6600 系统（iirc 有两组核心，其中每组共享 L2 缓存 - 无论如何都会解释结果；））上，我得到以下结果：

Running test for 5000 milliseconds with affinity 1 and 2
        Thread 00002000: 351883 errors
        Thread 00001000: 343523 errors
Running test for 5000 milliseconds with affinity 1 and 4
        Thread 00001000: 48073 errors
        Thread 00002000: 59813 errors
Running test for 5000 milliseconds with affinity 4 and 8
        Thread 00002000: 337199 errors
        Thread 00001000: 335467 errors
Running test for 5000 milliseconds with affinity 1 and 8
        Thread 00001000: 55736 errors
        Thread 00002000: 72441 errors