比方说,我有两个线程A并B写入一个全局布尔变量fA,fB分别最初设置为false受std::mutex对象保护mA并mB分别受以下对象保护:
// Thread A
mA.lock();
assert( fA == false );
fA = true;
mA.unlock();
// Thread B
mB.lock()
assert( fB == false );
fB = true;
mB.unlock()
是否可以观察修改fA,并fB在不同的线程不同的顺序C和D？换句话说,可以是以下程序
#include <atomic>
#include <cassert>
#include <iostream>
#include <mutex>
#include <thread>
using namespace std;
mutex mA, mB, coutMutex;
bool fA = false, fB = false;
int main()
{
thread …考虑一个原子读-修改-写操作，例如x.exchange(..., std::memory_order_acq_rel)。出于对其他对象的加载和存储进行排序的目的，这是否被视为：
具有获取-释放语义的单个操作？
或者，作为一个获取加载，然后是一个释放存储，附加保证其他加载和存储x将同时观察它们或两者都不观察？
如果它是 #2，那么尽管在加载之前或存储之后不能对同一线程中的其他操作进行重新排序，但仍然存在在两者之间重新排序的可能性。
作为一个具体的例子，考虑：
std::atomic<int> x, y;
void thread_A() {
x.exchange(1, std::memory_order_acq_rel);
y.store(1, std::memory_order_relaxed);
}
void thread_B() {
// These two loads cannot be reordered
int yy = y.load(std::memory_order_acquire);
int xx = x.load(std::memory_order_acquire);
std::cout << xx << ", " << yy << std::endl;
}
可以thread_B输出0, 1吗？
如果x.exchange()换成了x.store(1, std::memory_order_release);那么thread_B肯定能输出0, 1。是否应该exchange()排除额外的隐式负载？
cppreference听起来像 #1 是这种情况并且0, 1被禁止：
具有此内存顺序的读-修改-写操作既是获取操作又是释放操作。当前线程中的任何内存读取或写入都不能在此存储之前或之后重新排序。
但是我在标准中找不到任何明确的内容来支持这一点。实际上，该标准对原子读-修改-写操作几乎没有说明，除了 N4860 …
我正在努力了解 ARM STLR 的确切语义。
根据文档，它具有发布语义。所以如果你有 STLR 商店，你会得到：
[StoreStore][LoadStore]
X=r1
其中X是内存和r1一些寄存器。
问题是释放存储和获取加载无法提供顺序一致性：
[StoreStore][LoadStore]
X=r1
r2=Y
[LoadLoad][LoadStore]
在上述情况下，允许重新排序 X=r1 和 r2=Y。为了使这个顺序一致，需要添加一个[StoreLoad]：
[StoreStore][LoadStore]
X=r1
[StoreLoad]
r2=Y
[LoadLoad][LoadStore]
你通常在商店里这样做，因为装载更频繁。
在 X86 上，普通存储是发布存储，普通加载是获取加载。[StoreLoad] 可以通过 MFENCE 来实现，或者使用LOCK ADDL %(RSP),0Hotspot JVM 中的方式来实现。
当查看ARM文档时，LDAR似乎具有获取语义；所以这将是[LoadLoad][LoadStore]。
但 STLR 的语义很模糊。当我使用 memory_order_seq_cst 编译 C++ 原子时，只有一个 STLR；没有DMB。所以看来STLR比release store有更强的内存排序保证。对我来说，在栅栏层面上，STLR 相当于：
[StoreStore][LoadStore]
X=r1
[StoreLoad]
有人可以解释一下吗？
这是用于演示的简单代码片段。
有人告诉我，双重检查锁不正确。由于变量是非易失性的，编译器可以自由地重新排序调用或优化它们（有关详细信息，请参阅 codereview.stackexchange.com/a/266302/226000）。
但是我真的看到很多项目中确实使用了这样的代码片段。有人可以对这个问题有所了解吗？我用谷歌搜索并和我的朋友谈论它，但我仍然找不到答案。
#include <iostream>
#include <mutex>
#include <fstream>
namespace DemoLogger
{
void InitFd()
{
if (!is_log_file_ready)
{
std::lock_guard<std::mutex> guard(log_mutex);
if (!is_log_file_ready)
{
log_stream.open("sdk.log", std::ofstream::out | std::ofstream::trunc);
is_log_file_ready = true;
}
}
}
extern static bool is_log_file_ready;
extern static std::mutex log_mutex;
extern static std::ofstream log_stream;
}
//cpp
namespace DemoLogger
{
bool is_log_file_ready{false};
std::mutex log_mutex;
std::ofstream log_stream;
}
更新：谢谢大家。InitFd()确实有更好的实现，但它确实只是一个简单的演示，我真正想知道的是，双重检查锁定是否存在任何潜在问题。
有关完整的代码片段，请参阅https://codereview.stackexchange.com/questions/266282/c-logger-by-template。