C++11实现线程安全的单例模板

1、单例模式是一种创建型设计模式，核心是保证一个类在整个程序运行期间只有一个实例，并提供一个全局访问点来获取它。

2、线程安全是指在多线程并发环境下，代码或对象在被多个线程同时访问时仍能保持结果正确、状态一致且不发生竞态条件。

为了防止单例类在多线程情况下被多次实例化，需要保证单例模板在获取实例时仅仅只实例化一次。

例如懒汉式单例模板，这会导致在多个线程中被多次实例化

1
2
3
4
5
6
7
8
static std::shared_ptr<T> GetInstance() {
	if (_instance == nullptr) {
		std::cout << "singleton initialized" << std::endl;
    	_instance = std::shared_ptr <T>(new T);
    }
    
    return _instance;
}

测试（所用代码在下文）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include "TestClass.h"
#include <thread>

int main()
{
    std::thread t1([&]() {
        TestClass::GetInstance()->PrintAddress();
    });

	std::thread t2([&]() {
		TestClass::GetInstance()->PrintAddress();
	});


    t1.join();
    t2.join();

    return 0;
}

如下图所示，继承单例模板的类TestClass被多次初始化，是非线程安全的

image-20260407161520912

线程安全的模板

  1. 生命周期自动管理
    _instance 是静态成员，用 shared_ptr 可以在程序结束时自动析构对象（或最后一个引用释放时析构），不用手动 delete。
  2. 调用方也拿到 shared_ptr
    外部每次 GetInstance() 都会拷贝一个 shared_ptr，引用计数 +1，确保对象在被使用期间不会被销毁。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#ifndef SINGLETON_H
#define SINGLETON_H
#include <memory>

template <typename T>
class Singleton {
protected:
	Singleton() = default;
	Singleton(const Singleton<T>&) = delete;
	Singleton& operator=(const Singleton<T>& st) = delete;

	static std::shared_ptr<T> _instance;

public:
	static std::shared_ptr<T> GetInstance() {
		//不管调用几次，初始化都只有一次
        //static防止once_flag被二次初始化
		static std::once_flag s_flag;//第二次调用开始，s_flag为true
		std::call_once(s_flag, [&]() {
             std::cout << "singleton initialized" << std::endl;
			_instance = std::shared_ptr <T>(new T);
			//直接使用new而不是make_shared，
			//是因为单例类模板的构造函数是非public的，无法被make_shared访问
			//使用new就可以跳过单例模板类的构造函数，直接调用T的构造
		});

		return _instance;
	}

	void PrintAddress() {
		std::cout << "singleton address: " << _instance.get() << std::endl;
	}

	~Singleton() = default;
};

template <typename T>
std::shared_ptr<T> Singleton<T>::_instance = nullptr;//类内声明，类外初始化

#endif // !SINGLETON_H

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#pragma once
#include "singleton.h"

class TestClass : 
	public Singleton<TestClass>, 
	std::enable_shared_from_this<TestClass>
{
	friend class Singleton<TestClass>;
public:
	~TestClass() = default;

private:
	TestClass() = default;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include "TestClass.h"
#include <thread>

int main()
{
    std::thread t1([&]() {
        TestClass::GetInstance()->PrintAddress();
    });

	std::thread t2([&]() {
		TestClass::GetInstance()->PrintAddress();
	});


    t1.join();
    t2.join();

    return 0;
}

如下图所示，TestClass只被初始化了一次，且在线程t1和t2分别调用PrintAddress，输出结果完全一致，证明了在多线程下该单例模板是安全的，没有出现多次实例化的情况

image-20260407162010084

说些什么吧！

waline