单例模式之 懒汉模式普通版

直接上代码：

/*
单例模式可以保证：在一个程序当中，一个类有且只有一个实例，并提供一个访问
它的全局访问点

  在程序设计当中，很多情况下需要确保一个类只有一个实例
  例如： windopws系统中只能有一个窗口管理器
  某个程序中只能有一个日志输出系统
  一个GUI系统类库中，有且只有一个ImageManager
*/

#include <iostream>
#include "C1.H"
#include <windows.h>
#include <process.h>
using namespace std;

class CSingleton1
{
public:
	//获取实例对象静态函数
	static CSingleton1* GetInstance()
	{
		if (NULL == m_instance)
		{
			m_instance = new CSingleton1();
		}
		return m_instance;
	}
	//释放内存
	static void ReleaseInstance()
	{
		if (NULL != m_instance)
		{
			delete m_instance;
			m_instance = NULL;
			printf("释放内存\n");
		}
	}

	//测试打印函数
	void Print()
	{
		printf("print out CSingleton1\n");
	}

protected:

private:
	//构造函数私有化，让外部不能访问，达到只能有一个实例对象的效果
	CSingleton1()
	{
		printf("CSingleton1 Begin Construct\n");
		::Sleep(1000);//这里是为了看到效果
		printf("CSingleton1 End Construct\n");
	}
	//析构函数--虚函数，防止子类析构时不调用子类只调用父类的析构函数。
	virtual ~CSingleton1()
	{
		printf("CSingleton1 Destruct\n");
	}
private:
	//防止拷贝构造和赋值操作
	CSingleton1(const CSingleton1&);
	CSingleton1& operator=(const CSingleton1&);

private:
	static CSingleton1* m_instance;
};

CSingleton1* CSingleton1::m_instance = NULL;

unsigned int __stdcall thread(void*)
{
	printf("current Thread ID = %d\n", ::GetCurrentThreadId());
	CSingleton1::GetInstance()->Print();
	/*
	CSingleton1::ReleaseInstance();
	我们不能再线程中调用ReleaseInstance()函数，会导致程序崩溃
	*/
	return 0;
}

void TestMultThread()
{
	//这里创建三个线程
	for(int i = 0; i < 3; i++)
	{
		HANDLE t = (HANDLE)::_beginthreadex(NULL,0,thread,NULL,0,NULL);
		::CloseHandle((HANDLE)t);
	}

}

int main()
{

	TestMultThread();
	getchar();
	return 0;

}

/*
打印运行结果：

  current Thread ID = 7708
  current Thread ID = 6732    -- 两个线程获得所有权，判断m_instance都为NULL。因此都调用构造函数进行内存分配，内存还没来得急分配完成
  CSingleton1 Begin Construct
  CSingleton1 Begin Construct
  current Thread ID = 1700    --此时第三个线程获得所有权，判断m_instance还是NULL，因此又调用new操作符进行内存分配及成员变量初始化
  CSingleton1 Begin Construct
  CSingleton1 End Construct
  print out CSingleton1
  CSingleton1 End Construct
  print out CSingleton1
  CSingleton1 End Construct
  print out CSingleton1      --结果就是分配了三个CSingleton1的实例，违背了单例模式的规则：整个应用程序有且只有一个类的实例

1：我们创建3个辅助线程，外加main主线程，一共有4个线程
2：我们在每个辅助线程里面调用GetInstance()静态方法，由于每个人线程回调函数执行速度非常快，导致每个线程在判断
NULL == m_instance时，都返回TRUE，从而导致每个线程回调函数都会创建一个CSingleton1实例对象并返回指向该对象的
指针。

3：我们根本没办法进行CSingleton1的内存释放，因为在多线程当中，我们根本不知道是创建了一个实例还是2个3个。
*/

/*
 1:优点：该实现是一个“懒汉”单例模式，意味着只有在第一次调用GetInstance()静态方法
 的时候才会进行内存分配。如果整个程序不调用该静态方法，则不会分配内存。相对应的是
 “饿汉”单例模式

 2:缺点：
	1）“懒汉”模式虽然优点，但是每次调用GetInstance()静态方法的时候，必须判断
	NULL == m_instance,使程序相对开销增大
	2）由于使用指针动态内存分配，我们必须在程序结束的时候，手动的调用ReleaseInstance()静态
	方法，进行内存的释放。
	3）最大的缺点是线程不安全，根据该模式的定义，整个应用程序中，不管是单线程，还是多线程，都只能有且只有
	该类的一个实例。而在多线程中会导致多个实例的产生，从而导致运行代码不正确以及内存的泄露。

*/