我用过的设计模式（2）-- 单例模式

//这里是.h文件
//老板类单例
class Single_Boss
{
public:
    static Single_Boss *instence();//获取数据库单例
//重点在这个函数
	void run();
private:
    Single_Boss();
    ~Single_Boss();
    char *errmsg;

    static Single_Boss *Boss;//实例
};

//源文件

Single_Boss *Single_Boss::Boss= NULL;

Single_Boss::Single_Boss()
{
    cout << "Big Boss" << endl;	//debug
}

Single_Boss::~Single_Boss()
{
    cout<<"Seeyou Boss"<<endl;
}

Single_Boss* Single_Boss::instence()
{
    if(!Boss)
    {
        Boss= new Single_Boss();
    }
    	return Boss;
}

void Single_Boss::run(){
	cout<<"你好，欢迎光临XXX,请问需要点什么服务？"<<endl;
}

int main()
{
	//Single_Boss *boss = new Single_Boss();	//不信的话大可以将这一行放出来，下面那行屏蔽掉试试
    Single_Boss *boss= Single_Boss::instence();	//这是在类外使用单例
    
    boss->run();
    
    return 0;
}

Single_Boss* Single_Boss::instence()	//1
{										
    if(!Boss)							//2
    {									
        Boss= new Single_Boss();		//3
    }									
    return Boss;						
}										

Single_Boss* Single_Boss::instence()	//1
{					
	lock(db_mutex);	//假设这个锁我已经初始化过了					
    if(!Boss)							//2
    {									
        Boss= new Single_Boss();		//3
    }				
    unlock(db_mutex);	//上锁和解锁一定要同时写，就算忘记写中间步骤，也要先写解锁					
    
    return Boss;						
}	

Single_Boss* Single_Boss::instence()	//1
{				
	if(!Boss){			//一重锁定
		lock(db_mutex);				
	    if(!Boss)		//二重锁定				
	    {									
	        Boss= new Single_Boss();		
	    }				
	    unlock(db_mutex);	//上锁和解锁一定要同时写，就算忘记写中间步骤，也要先写解锁					
    }
    return Boss;						
}

Single_Boss *Single_Boss::Boss= new Single_Boss();

Single_Boss* Single_Boss::instence()
{
//不需要进行实例化
    //if(!Boss)
    //{
    //    Boss= new Single_Boss();
    //}
   	return Boss;
}

懒汉：在访问量较小时，采用懒汉实现。这是以时间换空间。

饿汉：由于要进行线程同步，所以在访问量比较大，或者可能访问的线程比较多时，采用饿汉实现，可以实现更好的性能。这是以空间换时间。

由于单例模式在内存中只存在一个对象，减少了内存的开支，特别是当对象需要频繁的创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显。

单例模式可以避免对内存的多重占用。

单例模式可以在系统设置全局的访问点，优化和共享资源访问。这招我经常用，也很喜欢，因为确实方便，做一个标志位单例类，负责所有数据表的映射处理。（要了解可以私信我）

单例模式一般没有接口，难以拓展。如果要拓展，考虑重构。

单例模式对于测试是不利的。在并发环境中，如果单例没有完成，是不能进行测试的。