C++ 在两个不同的变量上使用 memory_order_relaxed

Question

在 ThreadMethodOne 中加载时放宽变量 valA 和 valB 同步的最正确方法是什么(假设不存在 valA 和 valB 的虚假高速缓存行共享)？似乎我不应该将 ThreadMethodOne 更改为使用 memory_order_relaxed 来加载 valA，因为编译器可以在 valB.load 之后移动 valA.load，因为 valB.load 上的 memory_order_acquire 不能保护 valA 在 valB.load 之后移动一次做出了改变。似乎我不能在 valB.load 上使用 memory_order_relaxed，因为它不再与 ThreadMethodTwo 中的 fetch_add 同步。交换项目并减轻 valA 的负载会更好吗？

这是正确的更改吗？

nTotal += valB.load(std::memory_order_acquire);
nTotal += valA.load(std::memory_order_relaxed);

在 Compiler Explorer 上查看结果似乎显示当对 valA 或 valB 使用 memory_order_relaxed 时 ThreadMethodOne 生成相同的代码，即使我不交换指令的顺序也是如此。我还看到 ThreadMethodTwo 中的 memory_order_relaxed 仍然编译为与 memory_order_release 相同。将 memory_order_relaxed 更改为以下行似乎使其成为非锁定添加 'valA.store(valA.load(std::memory_order_relaxed) + 1, std::memory_order_relaxed);'但我不知道这样是否更好。

完整程序:

#include <stdio.h>
#include <stdlib.h>
#include <thread>
#include <atomic>
#include <unistd.h>

bool bDone { false };
std::atomic_int valA {0};
std::atomic_int valB {0};

void ThreadMethodOne()
{
    while (!bDone)
    {
        int nTotal {0};
        nTotal += valA.load(std::memory_order_acquire);
        nTotal += valB.load(std::memory_order_acquire);
        printf("Thread total %d\n", nTotal);
    }
}

void ThreadMethodTwo()
{
    while (!bDone)
    {
        valA.fetch_add(1, std::memory_order_relaxed);
        valB.fetch_add(1, std::memory_order_release);
    }
}

int main()
{
    std::thread tOne(ThreadMethodOne);
    std::thread tTwo(ThreadMethodTwo);

    usleep(100000);
    bDone = true;

    tOne.join();
    tTwo.join();

    int nTotal = valA.load(std::memory_order_acquire);
    nTotal += valB.load(std::memory_order_acquire);
    printf("Completed total %d\n", nTotal);
}

一个更好的样本离开原来的，因为它是评论中写的那个

#include <stdio.h>
#include <stdlib.h>
#include <thread>
#include <atomic>
#include <unistd.h>

std::atomic_bool bDone { false };
std::atomic_int valA {0};
std::atomic_int valB {0};

void ThreadMethodOne()
{
    while (!bDone)
    {
        int nTotalA = valA.load(std::memory_order_acquire);
        int nTotalB = valB.load(std::memory_order_relaxed);
        printf("Thread total A: %d B: %d\n", nTotalA, nTotalB);
    }
}

void ThreadMethodTwo()
{
    while (!bDone)
    {
        valB.fetch_add(1, std::memory_order_relaxed);
        valA.fetch_add(1, std::memory_order_release);
    }
}

int main()
{
    std::thread tOne(ThreadMethodOne);
    std::thread tTwo(ThreadMethodTwo);

    usleep(100000);
    bDone = true;

    tOne.join();
    tTwo.join();

    int nTotalA = valA.load(std::memory_order_acquire);
    int nTotalB = valB.load(std::memory_order_relaxed);
    printf("Completed total A: %d B: %d\n", nTotalA, nTotalB);
}

Answer 1

清理你的代码后，看看我的评论，我们得到类似的东西，

#include <atomic>
#include <iostream>

std::atomic_int valA {0};
std::atomic_int valB {0};

void ThreadMethodOne()
{
    int nTotalA = valA.load(std::memory_order_acquire);
    int nTotalB = valB.load(std::memory_order_relaxed);
    std::cout << "Thread total A: " << nTotalA << " B: " << nTotalB << '\n';
}

void ThreadMethodTwo()
{
    valB.fetch_add(1, std::memory_order_relaxed);
    valA.fetch_add(1, std::memory_order_release);
}

int main()
{
    std::thread tOne(ThreadMethodOne);
    std::thread tTwo(ThreadMethodTwo);

    tOne.join();
    tTwo.join();

    int nTotalA = valA.load(std::memory_order_acquire);
    int nTotalB = valB.load(std::memory_order_relaxed);
    std::cout << "Completed total A: " << nTotalA << " B: " << nTotalB << '\n';
}

这个项目的可能结果是:

Thread total A: 0 B: 0
Completed total A: 1 B: 1

或

Thread total A: 0 B: 1
Completed total A: 1 B: 1

或

Thread total A: 1 B: 1
Completed total A: 1 B: 1

它总是打印 Completed total A: 1 B: 1 的原因是线程 2 被加入并因此完成，它为每个变量加 1，并且线程 1 中的负载没有影响

如果线程 1 在线程 2 之前完全运行并完成，那么它显然会打印 0 0，而如果线程 2 在线程 1 之前完全运行并完成，那么线程 1 将打印 1 1。注意如何执行 memory_order_acquire 加载在线程 1 中不执行任何操作。可以轻松读取初始值0。

如果线程或多或少同时运行，那么 0 1 的结果也很微不足道:线程 1 可能执行它的第一行，然后线程 2 执行它的两行，最后线程 1 读取写入的值线程 2 到 valB(它不必因为它是放松的，但在那种情况下我们只得到 0 0 输出；至少它可能会读取 1，如果我们等待足够长的时间)。

所以，唯一感兴趣的问题是:为什么我们看不到 1 0 的输出？

原因是，如果线程 1 为 valA 读取了一个值 1，那么它必须是线程 2 写入的值。这里，读取其值的写入是写释放，而读取本身是读取获取。这会导致同步发生，导致线程 2 在写释放之前发生的每个副作用对线程 1 中在读释放之后的每个内存访问都是可见的。换句话说，如果我们读取 valA==1，那么随后对 valB 的读取(松弛或不松弛)将看到线程 2 对 valB 的写入，因此总是看到 1 而永远不会看到 0。

很遗憾，我不能对此多说，因为你的问题很不清楚:我不知道你期望或想要的结果是什么；所以我不能说发生这种情况的内存要求。