c++单例模式-6种单例层层迭代优化

定义
单例模式(Singleton Pattern,也称为单件模式),使用最广泛的设计模式之一。其意图是保证一个类仅有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。
他应该满足以下几点:

1:确保一个类只有一个实例被建立
2:构造函数应该声明为非公有,从而禁止外界创建实例。
3:拷贝操作和移动操作也应该禁止。
4:提供公有方法获取实例
5:支持多线程

版本1(懒汉)
缺点:
1:没有对资源进行释放
2:不支持多线程

    class Singleton {
    public:
	static Singleton * GetInstance() {
		if (_instance == nullptr) {
			_instance = new Singleton();
		}
		return _instance;
		}
		private:
		Singleton(){}//构造
		Singleton(const Singleton &clone){} //拷⻉构造
		Singleton& operator=(const Singleton&) {}
		stati	c Singleton * _instance;
	}
	Singleton* Singleton::_instance = nullptr;//静态成员需要初始化

版本2
缺点:
1:不支持多线程

    class Singleton {
	public:
	static Singleton * GetInstance() {
		if (_instance == nullptr) {
			_instance = new Singleton();
			atexit(Destructor);
		}
		return _instance;
		}
		~Singleton() {}
		private:
		static void Destructor() {
			if (nullptr != _instance) {
			delete _instance;
			_instance = nullptr;
		}
		}
		Singleton();//构造
		Singleton(const Singleton &cpy); //拷⻉构造
		Singleton& operator=(const Singleton&) {}
		static Singleton * _instance;
	}
	Singleton* Singleton::_instance = nullptr;//静态成员需要初始化

版本3(双重校验锁)
此代码是否感觉很安全,但实际上有重大问题
首先new一个对象时,分为三个步骤,1分配内存 2构造对象 3返回指针。所以常规顺序是123,但是编译器有时候为了优化会指令重排,导致顺序变成132,这里我们考虑这么一种情况
A线程:new1分配内存并按照指令重拍之后的顺序将2地址返回_instance 指针(这时候_instance 指针是非空的,但是还没有到达构造构造,此时时间片用完,线程切换)
B线程进入,此时发现_instance 是非空的,便直接将_instance返回给调用者,而调用着使用这个没有构造的对象将会发生不可预测的后果

指令重拍原因很多,比如编译器优化或者cpu指令流水线导致,具体可以查阅相关资料

    /****************************************
    static Singleton * GetInstance();
    加锁位置:由于除了第一次是需要new,后面调用都只是获取实例,所以在3.1处加锁会极大的损耗性能,故在3.2处通过if判断后才加锁,
    两次if判空原因:主要是考虑多线程环境线程切换因素
    *****************************************/
    #include 
	class Singleton { // 懒汉模式 lazy load
	public:
	static Singleton * GetInstance() {
		//std::lock_guard lock(_mutex); // 3.1 切换线程
		if (_instance == nullptr) {
			std::lock_guard<std::mutex> lock(_mutex); // 3.2
			if (_instance == nullptr) {
			_instance = new Singleton();
			atexit(Destructor);
			}
		}
		return _instance;
	}
	private:
		static void Destructor() {
			if (nullptr != _instance) {
				delete _instance;
				_instance = nullptr;
			}
		}
		Singleton(){} //构造
		Singleton(const Singleton &cpy){} //拷⻉构造
		Singleton& operator=(const Singleton&) {}
		static Singleton * _instance;
		static std::mutex _mutex;
	}
	Singleton* Singleton::_instance = nullptr;//静态成员需要初始化
	std::mutex Singleton::_mutex; //互斥锁初始化

版本4
解决版本三问题,但是代码显得很臃肿

    #include 
	#include 
	class Singleton {
	public:
		static Singleton * GetInstance() {
			Singleton* tmp = _instance.load(std::memory_order_relaxed);//加载实例
			std::atomic_thread_fence(std::memory_order_acquire);//获取内存屏障
			if (tmp == nullptr) {
				std::lock_guard<std::mutex> lock(_mutex);
				tmp = _instance.load(std::memory_order_relaxed);
				if (tmp == nullptr) {
					tmp = new Singleton;
					std::atomic_thread_fence(std::memory_order_release);//释放内存屏障
					_instance.store(tmp, std::memory_order_relaxed);
					atexit(Destructor);
				}
			}
			return tmp;
		}
	private:
		static void Destructor() {
		Singleton* tmp = _instance.load(std::memory_order_relaxed);
		if (nullptr != tmp) {
			delete tmp;
		}
	}
		Singleton(){}
		Singleton(const Singleton&) {}
		Singleton& operator=(const Singleton&) {}
		static std::atomic<Singleton*> _instance;
		static std::mutex _mutex;
	};
	std::atomic<Singleton*> Singleton::_instance;//静态成员需要初始化
	std::mutex Singleton::_mutex; //互斥锁初始化

版本5
c++11 magic static 特性:如果当变量在初始化的时候,并发同时进⼊声明语句,并发线程将会阻塞等待初始化结束。
缺点:无法继承

	class Singleton
	{
	public:
		~Singleton(){}
		static Singleton& GetInstance() {
			static Singleton instance;
			return instance;
	}
	private:
		Singleton(){}
		Singleton(const Singleton&) {}
		Singleton& operator=(const Singleton&) {}
	};

版本6

    template<typename T>
	class Singleton {
	public:
		static T& GetInstance() {
			static T instance; // 这⾥要初始化DesignPattern,需要调⽤DesignPattern 构造函数,同时会调⽤⽗类的构造函数。
			return instance;
		}
	protected:
		virtual ~Singleton() {}
		Singleton() {} // protected修饰构造函数,才能让别⼈继承
		Singleton(const Singleton&) {}
		Singleton& operator =(const Singleton&) {}
	};
	class DesignPattern : public Singleton<DesignPattern> {
		friend class Singleton<DesignPattern>; // friend 能让 Singleton 访问到 DesignPattern构造函数
	private:
		DesignPattern(){}
		DesignPattern(const DesignPattern&) {}
		DesignPattern& operator=(const DesignPattern&) {}
	}

你可能感兴趣的:(c++,单例模式,c++,开发语言)