單例模式

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()