C++设计模式之“Singleton”模式

"对象性能"模式

• 面向对象很好地解决了"抽象"的问题，但是必不可少地要付出一定的代价。对于通常情况来讲，面向对象的成本大都可以忽略不计。但是某些情况，面向对象所带来的成本必须谨慎处理。
• 典型模式
  Singleton
  Flyweight

---

# Singleton单件模式

• 在软件系统中，经常有这样一些特殊的类，必须保证他们在系统中只存在一个实例，才能确保它们的逻辑正确性、以及良好的效率。
• 如何绕过常规的构造器，提供一种机制来保证一个类只有一个实例？
• 这应该是类设计者的责任，而不是使用者的责任。

单例模式

• 构造函数和拷贝构造函数设为私有，因为默认情况下使公有的，让外界不能使用它，设为私有，否则就能通过构造函数实例化多个。
• 保证只能产生一个实例。

class Singleton{
private:
	Singleton();
	Singleton(const Singleton& other);
public：
	static Singleton*getInstance();
	static Singleton*m_instance;
	
};

线程非安全版本

Singleton*Singleton::getInstance() {
	if (m_instance == nullptr) {
		m_instance = new Singleton();
	}
	return m_instance;
}

Singleton*Singleton::m_instance = nullptr;

使用局部静态变量来解决存在的两个问题

上述代码中有两个问题，一个是多线程的情况下可能会出现new多次的情况。另外一个是程序退出后没有运行析构函数。
下面采用了静态对象来解决。

class Singleton {
private:
	static Singleton* m_instance;
	Singleton();
	~Singleton();

public:
	static Singleton*getInstance();
};


Singleton::Singleton() {
	cout << "构造函数的调用" << endl;
}

Singleton::~Singleton() {
	cout << "析构函数的调用" << endl;
}

Singleton*Singleton::getInstance() {
	static Singleton local_static;
	return &local_static;
}

int main()
{
	cout << "单例模式的第一次访问前" << endl;
	Singleton *s1 = Singleton::getInstance();
	cout << "单例模式的第一次访问后" << endl;
	cout << "单例模式的第二次访问前" << endl;
	Singleton *s2 = Singleton::getInstance();
	cout << "单例模式的第二次访问后" << endl;
	system("pause");
	return 0;

}

该代码可能在c++11之前的版本导致多次构造函数的调用，所以只能在较新的编译器上使用

线程安全版本，但锁的代价过高

下面这个版本使用了mutex以及静态成员来析构单例，该方案的劣势处于锁导致的速度慢，效率低。线程安全版本，但锁的代价过高
加锁实现了Singleton模式的初衷，保证了对象全局唯一，同时多线程安全
但是锁的代价过高,对读操作时浪费的，高并发的web服务器中，锁的代价是很大的

class Singleton {
private:
	static Singleton *m_instance;
	static pthread_mutex_t mutex;
	Singleton();
	~Singleton();
	class rememberFree {
	public:
		rememberFree() {
			cout << "成员构造函数调用" << endl;
		}
		~rememberFree() {
			cout << "成员析构函数调用" << endl;
		}
	};
	static rememberFree remember;
public:
	static Singleton*getInstance();
};
Singleton::Singleton() {
	cout << "Singleton构造函数的调用" << endl;
}

Singleton::~Singleton() {
	cout << "Singleton析构函数的调用" << endl;
}


Singleton*Singleton::getInstance() {
	pthread_mutex_lock(&mutex);
	if (m_instance == nullptr) {
		m_instance = new Singleton();
	}
	pthread_mutex_unlock(&mutex);
	return m_instance;
}

Singleton*Singleton::m_instance = nullptr;
pthread_mutex_t Singleton::mutex = PTHREAD_MUTEX_INITIALIZER;
Singleton::rememberFree Singleton::remember;

双检查锁，但由于内存读写reorder不安全

Singleton*Singleton::getInstance() {
	if (m_instance == nullptr) {
		pthread_mutex_lock(&mutex);
		if (m_instance == nullptr) {
			m_instance = new Singleton();
		}
		pthread_mutex_unlock(&mutex);
	}
	return m_instance;
}

假如线程A进入锁内并分配对象的空间，但是由于指令可能乱序，实际上导致m_instance被指向一块未被分配的内存，然后再在这块内存上进行初始化。但是在指向后，未初始化前另一个线程B可能通过getInstance获取到这个指针。

尝试使用局部变量并不能保证指令顺序

尝试使用临时变量强制指令运行顺序时，仍然会被编译器认为是无用的变量，然后被优化掉。下述代码是一个想法很好但是无法实现目的的代码：

Singleton*Singleton::getInstance() {
	if (m_instance == nullptr) {
		static mutex mtx;
		lock_guard<mutex> lock(mtx);
		if (m_instance == nullptr) {
			auto temp = new Singleton();
			m_instance = temp;
		}
	}
}

使用volatile来解决指令乱序在双检查锁中出现的问题

class Singleton {
private:
	static Singleton*volatile m_instance;
	Singleton();
	~Singleton();
	class rememberFree {
	public:
		rememberFree() {
			cout << "成员构造函数调用" << endl;
		}
		~rememberFree() {
			if (Singleton::m_instance != nullptr) {
				delete Singleton::m_instance;
			}
		}
	};
	static rememberFree remember;
public:
	static Singleton*getInstance();
};

Singleton::Singleton() {
	cout << "Singleton构造函数的调用" << endl;
}

Singleton::~Singleton() {
	cout << "Singleton析构函数的调用" << endl;
}

Singleton*Singleton::getInstance() {
	if (m_instance == nullptr) {
		static mutex mtx;
		lock_guard<mutex> lock(mtx);
		if (m_instance == nullptr) {
			auto tmp = new Singleton();
			m_instance = tmp;
		}
	}
	return m_instance;
}

Singleton*volatile Singleton::m_instance = nullptr;
Singleton::rememberFree Singleton::remember;


int main()
{
	cout << "单例模式的第一次访问前" << endl;
	Singleton *s1 = Singleton::getInstance();
	cout << "单例模式的第一次访问后" << endl;
	cout << "单例模式的第二次访问前" << endl;
	Singleton *s2 = Singleton::getInstance();
	cout << "单例模式的第二次访问后" << endl;
	system("pause");
	return 0;

}

在这份代码中，虽然tmp是volatile,但是*tmp不是，其成员也不是，所以仍然可能被优化。

C++11版本之后的跨平台实现

#include<atomic>
class Singleton {
private:
	static atomic<Singleton*>instance;
	Singleton();
	Singleton(const Singleton& other);
	~Singleton();
	class rememberFree {
		rememberFree() {
			cout << "成员函数构造调用" << endl;
		}

		~rememberFree() {
			Singleton*m_instance = instance.load(std::memory_order_relaxed);
			if (m_instance != nullptr) {
				delete m_instance;
			}
		}
	};

	static rememberFree remember;
public:
	static Singleton*getInstance();
};

Singleton::Singleton() {
	cout << "Singleton构造函数的调用" << endl;
}

Singleton::~Singleton() {
	cout << "Singleton析构函数的调用" << endl;
}

Singleton*Singleton::getInstance() {
	Singleton*tmp = instance.load(std::memory_order_relaxed);
	atomic_thread_fence(memory_order_acquire);  //获取内存fence
	if (tmp == nullptr) {
		static mutex mtx;
		lock_guard<mutex>lock(mtx);
		tmp = instance.load(memory_order_relaxed);
		if (tmp == nullptr) {
			tmp = new Singleton(); 
			atomic_thread_fence(memory_order_release);  //释放内存fence
			instance.store(tmp, memory_order_relaxed);
		}
	}
	return tmp;
}

atomic<Singleton*> Singleton::instance;
Singleton::rememberFree Singleton::remember;

模式定义

保证一个类仅有一个实例，并提供一个该实例的全局访问点。 ——《设计模式》GoF

要点总结

• Singleton模式的实例构造器可以设置为protected以允许子类派生。
• Singleton模式一般不要支持拷贝构造函数和Clone接口，因为有可能导致多个对象实例，与Singleton模式的初衷违背。
• 如何实现多线程环境下的安全的Singleton?注意对双检查锁的正确实现。