单例模式

1、应用场景

在应用这个模式时，单例对象的类必须保证只有一个实例存在，单例模式只允许创建一个对象，因此节省内存，加快对象访问速度，因此对象需要被公用的场合适合使用，如多个模块使用同一个数据源连接对象等等。如：
（1）需要频繁实例化然后销毁的对;
（2）创建对象时耗时过多或者耗资源过多，但又经常用到的对象;
（3）有状态的工具类对象;
（4）频繁访问数据库或文件的对象。
以下都是单例模式的经典使用场景：
（1）资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。
（2）控制资源的情况下，方便资源之间的互相通信。如线程池等。

原理：
构造函数私有化，如果该对象不存在就构造一个，如果存在了就不再构造了。
实现过程：
（1）创建一个类；
（2）将该类的构造函数私有化；
（3）以静态方法返回实例。

2、应用模式

2.1 饿汉模式：
即无论是否使用了该对象，在一开始的时候就创建该对象
2.1.1 C++实现

#include <iostream>
using namespace std;

class Singleton
{
public:
   static Singleton *Instance()
	 {
		return m_Instance;
         };

private:

     Singleton(){};
     Singleton(const Singleton&);
     Singleton & operator=(const Singleton &){};
     static Singleton * m_Instance; 
};
//在此进行实例化
Singleton * Singleton::m_Instance = new Singleton();

int main()
{
	Singleton * Singleton1 = Singleton::Instance();
        Singleton * Singleton2 = Singleton::Instance();
        cout << "Singleton1 Address:"<<Singleton1<<endl;
        cout << "Singleton2 Address:"<<Singleton2<<endl;

	return 0;
}

2.1.2 Python实现

import threading
import time        
class Singleton(object):
    def __init__(self):
        time.sleep(10)
obj = Singleton() 
def task(arg):
    #类此实例化,不安全  
    print(obj)

if __name__=='__main__':
    
    for i in range(10):
        t = threading.Thread(target=task,args=[i,])
        t.start()
    

2.2 懒汉模式
第一次用到类实例的时候才会去实例化。
2.2.1 C++实现（此例在多线程时不安全，需要加线程锁方可用）

#include <iostream>
using namespace std;
class Sigletion
{
    protected:
    Sigletion()
    {

    }
    public:	
    static Sigletion* getInstance()
    {
        if(instance==NULL)
        {
            instance = new Sigletion();
        }
    }

    private:
    static Sigletion* instance;
};

//先初始化为空，等真正用上这个单例的时候再创建这个例。
Sigletion* Sigletion::instance = NULL;  

int main()
{
	Sigletion* Sigletion1 = Sigletion::getInstance();
	Sigletion* Sigletion2 = Sigletion::getInstance();

       cout<<"Sigletion1 address "<<Sigletion1<<endl;
       cout<<"Sigletion2 address "<<Sigletion2<<endl;

	return 0;
}

2.2.2 Python实现

import threading
import time        
class Singleton(object):
    _instance=None
    def __init__(self):
       
        time.sleep(1)
    
    @classmethod
    def Instance(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            Singleton._instance = Singleton(*args, **kwargs)
        return Singleton._instance

def task(arg):
    #类此实例化,不安全       
    obj = Singleton.Instance()
    print(obj)

if __name__=='__main__':
    for i in range(10):
        t = threading.Thread(target=task,args=[i,])
        t.start()