在我的 C++ 代码中，我保留了一个指向对象的指针 应该懒惰地创建，即仅应请求创建。 我有以下代码，这显然不是线程安全的。
LAZY* get_lazy()
{
if (0 == _lazy)
_lazy = create_lazy();
return _lazy;
}
我想知道我应该在这里使用哪种同步？ 我知道 Boost.thread 支持一次性初始化。 但我希望有一个仅使用 TBB + C++ 的简单解决方案。 我还应该注意...
_lazy 创建为静态对象（我实际上想保留此类延迟创建的对象的无限数组）LAZY 对象不能过度分配（创建非常昂贵）【问题讨论】：
标签： c++ multithreading thread-safety tbb
您需要一个本地互斥体 (tbb::mutex)，以确保您只创建一次惰性对象。
#include <tbb/mutex.h>
tbb::atomic<LAZY*> _lazy;
tbb::mutex myMutex;
LAZY* GetLazy()
{
if (0 == _lazy)
{
myMutex.lock();
if (0 == _lazy)
_lazy = create_lazy();
myMutex.unlock();
}
return _lazy;
}
【讨论】：
myMutex 声明为GetLazy() 中的静态变量，还是可以的。我说的对吗？
static 函数变量的构造函数不是线程安全的，所以你绝对不应该这样做。
偶尔多次拨打create_lazy 可以吗？如果是这样，这是一个非常轻量级、仅使用 TBB 的高效解决方案：
tbb::atomic<LAZY*> lazy;
if(!lazy)
{
LAZY *newlazy = create_lazy();
if(lazy.compare_and_swap(newlazy, 0))
{
// lazy was initialized elsewhere.
delete newlazy;
}
}
// use lazy.
这将比 Maciej 的解决方案产生更少（零！）的开销，但只有在线程之间在该特定变量上存在争用的情况下偶尔多次调用 create_lazy 时才有效。
避免互斥体和多次调用create_lazy 的一种方法是使用自旋循环。如果存在争用，这将使用比互斥锁更多的 CPU，但开销仍然很低：
tbb::atomic<LAZY*> lazy;
static int sentry;
if(!lazy && !lazy.compare_exchange((LAZY*)&sentry, 0))
{
// lazy is set to a sentry value while being allocated.
try{ lazy = create_lazy(); }
catch(...) { lazy = 0; throw; }
}
else
{
// yield the thread while lazy is still set to the sentry.
while(lazy == (LAZY*)&sentry)
{
tbb::this_tbb_thread::yield();
}
}
// use lazy.
【讨论】：
LAZY对象不能被过度分配，因为创建它们非常昂贵，而且它们会使用很多其他资源。
您还可以查看 TBB 内部如何解决此问题。代码中要搜索的名字是atomic_do_once；它是用于延迟初始化的内部（在撰写本文时）TBB 函数。这个函数和辅助东西的定义在src/tbb_misc.h，其他文件也有几个地方用到。
基本思想与@CoryNelson 的答案相同，但在三态标志的帮助下进行了概括（请参阅enum do_once_state）。需要创建一个tbb::atomic<do_once_state> 类型的静态变量，并将它与应该运行一次的函数/仿函数一起传递给对atomic_do_once 的调用。例如：
void initialize_once();
static tbb::atomic<tbb::internal::do_once_state> init_state;
/*...*/
// Safe to execute concurrently
tbb::internal::atomic_do_once( &initialize_once, init_state );
对于长时间运行的初始化，最好使用@MaciejDopieralski 推荐的tbb::mutex，因为它通过使等待线程进入睡眠状态来避免过多的 CPU 使用。请注意，TBB 中的大多数其他互斥体风格也会旋转，而不是睡眠。
【讨论】：