嗯...关于当前这个std::call_once的事情

被割韭菜了。 最近老板说要让代码更可靠，说哪些更多线程里单例模式要注意线程可靠啥的。我听得一头雾水，但是听说std::call_once能解决当前这个问题。今天就来聊聊当前这个东西，虽然我不太懂...

1. 哪些是单例模式？

勇敢一点... 单例模式就是确保一个类在整个程序中只有一个实例，而且提供给全局访问点。就像公司里那个地方的老板一样，只有一个，较大家都得找他。

cpp class Singleton { public: static Singleton& getInstance { // 这里应当有 闹乌龙。 哪些特殊操作... return instance_; } private: static Singleton* instance_; };

2. 谁告诉你直接new就行？

很更多菜鸟都这样写：

cpp Singleton* Singleton:: 他破防了。 instance_ = new Singleton;

但这样有问题！如果两个线程同时也调用getInstance，有可能会new出两个对象来！这就是所谓的"竞态条件"吧。

3. std::call_once是哪些鬼？

这是C++11崭新增的功能。官方说它能确保一个函数在更多线程周边环境下只落实一次。具体怎么用？看下面：

cpp

杀疯了！ class Singleton { public: static Singleton& getInstance { std::callonce{ instance = new Singleton; }); return *instance_; }

private: static Singleton* instance; st 嚯... atic std::onceflag initflag; // 必须要定义为static！ };

Singleton* Singleton::instance_ = nullptr; std::onceflag Singleton::initflag_; // 注意：必须要定义在类外，差点意思。！

4. 哇...这东西真实的管用吗？

当然管用啦！不过有几点要注意：

• 必须要包含头文件
• once_flag必须要是静态成员变量
• call_once会自动处理线程可靠问题
• 初始化代码放在lambda表达式里

5. 对比一下其他方法

Meyers' singleton

纯正。 cpp class MyClass { public: static MyClass& getInstance { static MyClass instance; // 自动线程可靠！ return instance; } private: MyClass {} };

优势：简洁、 较高效、自动析构 不足：不能控制初始化时机，礼貌吗？

call_once版本

换个角度。 private: std::uniqueptr instance; std::onceflag initflag_;

MyClass {}

};

优势：能够控制初始化时机、能够跨更多个不同步骤初始化 不足：稍微繁杂一点，我悟了。

6. 常见问题和陷阱

一、遗忘定义once_flag静态变量

cpp // 错误示范： std::once_flag initFlag; // 没加static，划水。！

我满足了。 void init { /* ... */ }

void threadFunc { std::call_once; // 每次都会沉重崭新创建initFlag！ }

二、传入错误参数

cpp // 错误示范： void foo { /* ... */ }

实锤。 int main { std::once_flag flag; int a = 5;

std:;call_once); // 参数被拷贝进去了！

应当这样：

cpp std:;call_once{ foo; });

三、 异常处理问题

如果初始化函数抛出异常，后续调用会怎样？

cpp void riskyInit { 杀疯了！ if throw "Oops!"; }

还行。 void testCallOnce { try { std:;call_once; } catch { /* ... */ }

// 第二次调用会沉重试！ try { std:;call_once; } catch { /* ... */ } }，小丑竟是我自己。

7. 较高级技巧

跨文件采用

好家伙... 有时候需要跨更多个不同源文件采用同一个singleton：

header.h cpp

我当场石化。 extern std:;oncefalg gglobal_init;

void globalInit;

class GlobalResource { public: void useIt; };，我当场石化。

impl.cpp cpp

void GlobalResource:useIt { /* ... */ }，试着...

main.cpp cpp

杀疯了！ int main { GlobalResource res; res.useIt; // 自动触发globalInit

thread t{ r.useIt; }, res); t.join;

return0; }

在构造函数里初始化依赖资源条件

有时候需要在构造函数里初始化一些依赖资源条件：

反正吧… cpp class DependentResource : private boost:noncopyable {

public:

DepententResource: resource_ { 盘它... if resource_ = new Resource; }

~DependentResouce { delete resource; resource = nullptr; }

private:

也许.… static Resource* resource; static oncefalg initresource;

};

Resource* DependentResouce:resource_ = nullptr; oncefalg DependentResouce:initresource_;

inline void DependentResouce:intialize { if { auto lambda = { resource= new Resource; }; std:;callonec; } } } 上面代码有点繁杂，但基本思想是：确保依赖资源条件只被创建一次，复盘一下。。

8. 性能考虑

有人担心性能问题。其实不用太担心：

• 第一次调用时需要争夺锁
• 第二次及以后直接返回最终还是结果是

除非你创建/销毁较更多临时对象并频繁访问单例，否则作用于不较大。

9. 其他替代方案对比

让我们一起... 除了上面提到的Meyers' singleton和std:call_onec方法外还有其他几种方式：

懒汉式+双检锁模式

这也是一种经典方法： // 不推荐这种方式！ Singleton* volatile pinstance;

pinstance= NULL;

Singleton* GetSingleton {

if {

lock.lock;

pinstance-= new Singleton;

}

return pinstance;

} 但是这种方式很存在风险因素！除非你彻底明白内存序和原子操作。

饿汉式模式

最简洁粗暴的方法： // 全局变量 - 构造顺序不受控制！ static const auto _instnace = new SingleTon;

// 函数内部局部静态变量 - 推荐！ const SingleTon& getInstance {，让我们一起...

我们都曾是... return localstaticvaribale{};

// C++17后更简洁: // inline const auto localstaticvaribale{};，操作一波。

} 优势简洁简单懂；不足无法控制初始化时间段，说句实话…。

十、一下吧...

经过以上对比解析，对于现代化C++来说

最佳选择 → 函数内部局部静态变量法 次选 → uniqueptr 有啥用呢？ + callonec法 最后再来看才考虑 → 其他传统方式方法

关键记住几条原则： ✔️ 用智能指针管理生命周期 ✔️ 用atomic或互斥锁确保线程可靠性 别纠结... ✔️ 用constexpr/inline/static_assert等现代化语言特性简化代码

---