/*************************************************************************
	> File Name: Singleton.cpp
	> Created Time: Tue 31 Oct 2017 10:20:58 PM CST
 ************************************************************************/
#include <iostream>
using namespace std;
#include <pthread.h>

//懶漢式 （建立的時候採取new例項）以時間換取空間，執行緒不安全
class singleton_L
{
    public:
        static singleton_L* getinstance()
        {
            if(instance == NULL)
            {
                instance = new singleton_L();
            }
            return instance;
        }
        ~singleton_L()
        {
            if(instance != NULL)
            {
                delete instance;
                instance = NULL;
            }
        }
    private:
        singleton_L(){}
        static singleton_L*  instance;
};

singleton_L*  singleton_L::instance = NULL;


//餓漢式（在定義例項的時候就去new物件）以空間換時間
class singleton_E
{
    public:
        static singleton_E* getinstance()
        {
            return instance;
        }

    private:
        singleton_E(){}
        static singleton_E* instance;
};

singleton_E* singleton_E::instance = new singleton_E();

//懶漢式 執行緒安全式（雙檢鎖）
/*
  所謂雙重檢查加鎖機制，指的是：並不是每次進入getInstance方法都需要同步，而是先不
同步，進入方法過後，先檢查例項是否存在，如果不存在才進入下面的同步塊，這是第一重
檢查。進入同步塊過後，再次檢查例項是否存在，如果不存在，就在同步的情況下建立一個
例項，這是第二重檢查。這樣一來，就只需要同步一次了，從而減少了多次在同步情況下進
行判斷所浪費的時間。
*/
class singleton_L_Lock
{
    public:
        static singleton_L_Lock* getinstance()
        {
            if(instance == NULL)
            {
                pthread_mutex_lock(&mutex);
                if(instance == NULL)
                    instance = new singleton_L_Lock();
                pthread_mutex_unlock(&mutex);
            }
            return instance;
        }
        ~singleton_L_Lock()
        {
            if(instance != NULL)
            {
                delete instance;
                instance = NULL;
            }
        }
    public:
        static pthread_mutex_t mutex;
    private:
        singleton_L_Lock()
        {
            pthread_mutex_init(&mutex, NULL);
        }
    private:
        static singleton_L_Lock*  instance;
};

singleton_L_Lock* singleton_L_Lock::instance = NULL;
pthread_mutex_t   singleton_L_Lock::mutex;  

int main()
{
    singleton_L* p  = singleton_L::getinstance();
    singleton_L* p1 = singleton_L::getinstance();
    singleton_L* p2 = singleton_L::getinstance();

    cout << p  << endl;
    cout << p1 << endl;
    cout << p2 << endl;
    
    cout << "=================" << endl;
    singleton_E* E  = singleton_E::getinstance();
    singleton_E* E1 = singleton_E::getinstance();
    singleton_E* E2 = singleton_E::getinstance();

    cout << E  << endl;
    cout << E1 << endl;
    cout << E2 << endl;

    cout << "=================" << endl;
    singleton_L_Lock* L  = singleton_L_Lock::getinstance();
    singleton_L_Lock* L1 = singleton_L_Lock::getinstance();
    singleton_L_Lock* L2 = singleton_L_Lock::getinstance();

    cout << L  << endl;
    cout << L1 << endl;
    cout << L2 << endl;
    
    return 0;
}