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

Posted 2023-02-22

【中文标题】C++ 在两个不同的变量上使用 memory_order_relaxed

【英文标题】：C++ using memory_order_relaxed on two different variables

【发布时间】：2017-10-12 18:40:39

【问题描述】：

在 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 更改为以下行似乎使其成为非锁定 add '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);

保留原始样本的更好样本，因为它是 cmets 中所写的样本

#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);

【问题讨论】：

你为什么觉得你需要放松订购？

这更多的是更好地理解主题。

youtube.com/watch?v=c1gO9aB9nbs 关于该主题的权威演讲。

由于排序参数的使用是不正确的，如果你改变它们会发生什么推理是没有用的。查看 Jeff Preshing 的 blog 以获取有关此主题的更多信息。另外，bDone 必须是原子类型

目前关于 C++ 内存模型的最佳资料来源是 manning.com/books/c-plus-plus-concurrency-in-action 的第 5 章。从我读过的内容来看，即使是我建议的替换行也不会创建 valA 的任何同步，因为 valB 正确地获取/释放同步。在这种情况下，valA 似乎可以是任何数字，或者只是保持为 0，而没有任何缓存刷新到正在运行 ThreadMethodOne 的线程。因此，如果我在任何地方对 valB 使用放松，那么 valA 的处理方式并没有什么不同。在任何地方使用松弛可能会导致 valA 和 valB 看起来乱七八糟。

【参考方案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。

不幸的是，我不能对此多说，因为您的问题非常不清楚：我不知道您期望结果是什么，或者想要成为什么；所以我不能说发生这种情况的内存要求。