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

在ThreadMethodOne中加载时，放松变量valA和valB同步的最正确方法是什么(假设没有错误的valA和valB缓存线共享)？我似乎不应该将ThreadMethodOne更改为使用memory_order_relaxed来加载valA，因为编译器可以在valB.load之后移动valA.load，因为一旦进行更改，valB.load上的memory_orderAcquire就不能保护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);

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

完整程序：

#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 %dn", 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 %dn", 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: %dn", 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: %dn", nTotalA, nTotalB);
}