C++ 单例模式 与线程安全

单例模式：作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。


　　单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。在下面 
的对象图中，有一个"单例对象"，而"客户甲"、"客户乙" 和"客户丙"是单例对象的三个客户对象。可以看到，所有的客户对象共享一个单例对 
象。而且从单例对象到自身的连接线可以看出，单例对象持有对自己的引用。

一些资源管理器常常设计成单例模式。让一个类产生同一个对象对客户端服务的时候，比如管理数据库连接,管理文件IO等，这时我们就要使用 
到单例模式。下面是该模式的C++实现(注泽说明)


#include <iostream>    
using namespace std;    
//单例类的C++实现    
class Singleton    
{    
private:    
Singleton();//注意:构造方法私有    
virtual ~Singleton();    
static Singleton* instance;//惟一实例    
int var;//成员变量(用于测试)    
public:    
static Singleton* GetInstance();//工厂方法(用来获得实例)    
int getVar();//获得var的值    
void setVar(int);//设置var的值    
};   

//构造方法实现    
Singleton::Singleton()    
{    
this->var = 20;    
cout<<"Singleton Constructor"<<endl;    
}    
Singleton::~Singleton()    
{    
     delete instance;    
}    
//初始化静态成员    
Singleton* Singleton::instance=new Singleton();    
Singleton* Singleton::GetInstance()    
{    
return instance;    
}    
//seter && getter含数    
int Singleton::getVar()    
{    
return this->var;    
}    
void Singleton::setVar(int var)    
{    
this->var = var;    
}    
//main    
int main(int argc, char* argv[])    
{    
Singleton *ton1 = Singleton::GetInstance();    
Singleton *ton2 = Singleton::GetInstance();    
cout<<"ton1 var = "<<ton1->getVar()<<endl;    
ton1->setVar(150); 
cout<<"ton2 var = "<<ton2->getVar()<<endl;

return 0;    
}

输出如下:

Singleton Constructor
   ton1 var = 20
   ton2 var = 150

在输出结果中，构造方法只调用了一次，ton1与ton2是指向同一个对象的。

单例模式是构造函数被私有化，并且唯一的实例在类中的私有成员中被定义成static,
类的初始化就做了一次。
Singleton Constructor
   ton1 var = 20
   ton2 var = 150

所以所有的新的对象都只用这一个实例。和静态成员变量有区别
Singleton *ton1 = Singleton::GetInstance();    

Singleton *ton2 = Singleton::GetInstance();    

class Singleton 
{ 
public :
        static Singleton * GetSingleInstance();
};


Singleton * Singleton::GetSingleInstance()
{
   static  Singleton *ins_ptr = NULL;
   if( !ins_ptr )
   {
       lock();//
       if(!ins_ptr)
       {
          Singleton * temp_ptr = new Singleton();
          ins_ptr = temp_ptr;
       }
       unlock();//
   }
   
   return ins_ptr;

 
}

几个条件：
1. 单例的构造是线程安全的。我建议在程序还只有单个线程的时候构造实例，这样就不用double-lock模式，Meyers模式就足够了：
class Single
{
    Single(){}
public:
    static Single & getInst(){
        static Single s;
        return s;
    }
};

2. 单例本身是线程安全的，即调用单例对象的接口的时候，必须保证线程安全；
3. 单例的析构是线程安全的。如果程序里面不要显式析构单例对象，就让OS回收吧，这样程序员不需要有做任何事情。