函数局部静态 const 对象的线程安全初始化

Question

这个问题 让我对多年来一直遵循的做法提出质疑。

对于函数本地静态 const 对象的线程安全初始化，我保护对象的实际构造，但不保护函数本地引用的初始化 em> 指的是它。类似这样的：

namespace {
  const some_type& create_const_thingy()
  {
     lock my_lock(some_mutex);
     static const some_type the_const_thingy;
     return the_const_thingy;
  }
}

void use_const_thingy()
{
  static const some_type& the_const_thingy = create_const_thingy();

  // use the_const_thingy

}

这个想法是锁定需要时间，如果引用被多个线程覆盖，那也没关系。

我想知道这

1. 在实践中是否足够安全？
2. 根据规则安全吗？ （我知道，当前的标准甚至不知道什么是“并发”，但是践踏已经初始化的引用又如何？其他标准（例如 POSIX）是否有与此相关的内容？）

我想知道这一点的原因是我想知道我是否可以保留代码原样，或者我是否需要返回并修复这个问题。

---

对于好奇的人：

我有很多这样的函数局部静态 const 对象使用的是首次使用时从 const 数组初始化并用于查找的映射。例如，我有一些 XML 解析器，其中标记名称字符串映射到 enum 值，因此我可以稍后切换标记的 enum价值观。

---

由于我得到了一些关于该怎么做的答案，但还没有得到我实际问题的答案（参见上面的 1. 和 2.），所以我将对此开始悬赏。再次：
我对我能做什么不感兴趣相反，我真的很想知道这个。

Answer 1

这是我第二次尝试回答。我只回答你的第一个问题：

1. 实践中足够安全吗？

不。正如您所说，您只是确保对象创建受到保护，而不是对象引用的初始化。

在没有 C++98 内存模型并且编译器供应商没有明确声明的情况下，无法保证写入代表实际引用的内存以及写入保存初始化标志值的内存（如果是）它是如何实现的）以供参考，从多个线程中以相同的顺序看到。

正如您还所说，使用相同的值多次覆盖引用应该不会产生语义差异（即使存在单词撕裂，这在您的处理器架构上通常不太可能甚至可能是不可能的），但有一种情况很重要：< em>当多个线程在程序执行过程中第一次竞相调用该函数时。在这种情况下，这些线程中的一个或多个可能会在初始化实际引用之前看到已设置的初始化标志。

您的程序中有一个潜在的错误，您需要修复它。至于优化，我确信除了使用双重检查锁定模式之外还有很多优化。

Answer 2

这是我的看法（如果你真的无法在线程启动之前初始化它）：

我见过（并使用过）类似的东西来保护静态初始化，使用 boost::once

#include <boost/thread/once.hpp>

boost::once_flag flag;

// get thingy
const Thingy & get()
{
    static Thingy thingy;

    return thingy;
}

// create function
void create()
{
     get();
}

void use()
{
    // Ensure only one thread get to create first before all other
    boost::call_once( &create, flag );

    // get a constructed thingy
    const Thingy & thingy = get(); 

    // use it
    thingy.etc..()          
}

在我的理解中，这样所有线程都会等待boost::call_once 除外，它将创建静态变量。它只会被创建一次，然后就不会再被调用。然后你就不再有锁了。

Answer 3

因此，规范的相关部分是 6.7/4：

在允许实现静态初始化命名空间范围内具有静态存储持续时间的对象的相同条件下，允许实现对具有静态存储持续时间的其他本地对象执行早期初始化（3.6.2）。否则，这样的对象将在控制第一次通过其声明时被初始化；这样的对象在初始化完成后就被认为已初始化。

假设第二部分成立（对象在控制第一次通过其声明时被初始化），您的代码可以被认为是线程安全的。

通读 3.6.2，似乎允许的早期初始化正在将动态初始化转换为静态初始化。由于静态初始化必须在任何动态初始化之前发生，并且因为我想不出任何方法来创建线程，直到动态初始化< /em>，这样的早期初始化也将保证构造函数被调用一次。

更新

因此，对于调用 the_const_thingy 的 some_type 构造函数，根据规则，您的代码是正确的。

这就留下了关于覆盖引用的问题，而规范绝对没有涵盖这一点。也就是说，如果您愿意假设引用是通过指针实现的（我认为这是最常见的方法），那么您要做的就是用指针已经保存的值覆盖它。所以我的看法是这在实践中应该是安全的。

Answer 4

我不是标准主义者...

但是对于您提到的用途，为什么不在创建任何线程之前简单地初始化它们？许多单例问题是由于人们使用惯用的“单线程”延迟初始化而引起的，而他们可以在加载库时简单地实例化该值（就像典型的全局变量一样）。

仅当您使用另一个“全局”中的该值时，惰性时尚才有意义。

另一方面，我见过的另一种方法是使用某种协调：

• “Singleton”在库加载期间在“GlobalInitializer”对象中注册其初始化方法
• “GlobalInitializer”在任何之前在“main”中调用线程已启动，

尽管我可能没有准确地描述它。

Answer 5

简而言之，我认为：

• 对象初始化是线程安全的，假设“some_mutex”在进入“create_const_thingy”时完全构造完毕。

• “use_const_thingy”内部对象引用的初始化不保证是线程安全的；它可能（如您所说）会被多次初始化（这不是什么问题），但它也可能会受到单词撕裂的影响，这可能会导致未定义的行为。

[我假设 C++ 引用被实现为使用指针值对实际对象的引用，理论上可以在部分写入时读取]。

因此，尝试回答您的问题：

1. 实践中足够安全：很有可能，但最终取决于指针大小、处理器架构和编译器生成的代码。这里的关键可能是指针大小的写/读是否是原子的。

2. 根据规则安全：嗯，C++98 中没有这样的规则，抱歉（但你已经知道了）。

   根据

---

更新：发布此答案后，我意识到它只关注真正问题的一小部分，深奥的部分，因此决定发布另一个答案而不是编辑内容。我将内容保留为“原样”，因为它与问题有一定的相关性（也是为了谦虚自己，提醒我在回答之前要多思考一下）。

Answer 6

我编写的进程间套接字已经足够让我做噩梦了。为了在具有 DDR RAM 的 CPU 上实现线程安全，您必须对数据结构进行缓存行对齐，并将所有全局变量连续打包到尽可能少的缓存行中。

未对齐的进程间数据和松散打包的全局变量的问题是，它会导致缓存未命中造成别名。在使用 DDR RAM 的 CPU 中，（通常）有一堆 64 字节缓存线。当您加载一个缓存行时，DDR RAM 会自动加载更多的缓存行，但第一个缓存行始终是最热的。高速发生的中断会发生什么情况，缓存页面将充当低通滤波器，就像模拟信号一样，并且会过滤掉导致完全令人困惑的错误的中断数据，如果您不知道发生了什么事。对于未紧密包装的全局变量也是如此。如果它占用多个缓存行，它将不同步，除非您拍摄关键进程间变量的快照并将它们传递到堆栈和寄存器以确保数据正确同步。

.bss 部分（即存储全局变量的位置）将被初始化为全零，但编译器不会为您缓存行对齐数据，您必须自己执行此操作，这也可能是一个好地方使用C++ 就地构造来学习背后的数学。对齐指针的最快方法请阅读这篇文章; 我试图弄清楚我是否想出了这个技巧，代码如下：

inline char* AlignCacheLine (char* buffer) {
  uintptr_t offset = ((~reinterpret_cast<uintptr_t> (buffer)) + 1) & (63);
  return buffer + offset;
}

char SomeTypeInit (char* buffer, int param_1, int param_2, int param_3) {
  SomeType type = SomeType<AlignCacheLine (buffer)> (1, 2, 3);
  return 0xff;
}

const SomeType* create_const_thingy () {
  static char interprocess_socket[sizeof (SomeType) + 63],
              dead_byte = SomeTypeInit (interprocess_socket, 1, 2, 3);
  return reinterpret_cast<SomeType*> (AlignCacheLine (interprocess_socket));
}

根据我的经验，您将必须使用指针，而不是引用。

Answer 7

只需在开始创建线程之前调用该函数，即可保证引用和对象。或者，不要使用如此糟糕的设计模式。我的意思是，为什么要对静态对象有静态引用？为什么还要有静态对象？这没有任何好处。单例是一个糟糕的主意。

Answer 8

这似乎是我能想到的最简单/最干净的方法，而不需要所有的互斥量：

static My_object My_object_instance()
{
    static My_object  object;
    return object;
}

// Ensures that the instance is created before main starts and creates any threads
// thereby guaranteeing serialization of static instance creation.
__attribute__((constructor))
void construct_my_object()
{
    My_object_instance();
}