单例模式

1.饿汉模式

#include<iostream>
using namespace std;

class singleton1{
private:
    static singleton1 s;
    int i;
    singleton1(int x) :i(x){}
    singleton1(const singleton1 &);
    singleton1& operator=(singleton1 &);
public:
    static singleton1& instance(){//static singleton1&
        return s;
    }
    int getValue(){
        return i;
    }
    void setValue(int x){
        i = x;
    }
};

singleton1 singleton1::s(47);//此处不能写static


int main(){
    singleton1& s = singleton1::instance();//&，否则错误
    cout << s.getValue() << endl;

    singleton1& s2 = singleton1::instance();
    s2.setValue(9);

    cout << s.getValue() << endl;
    return 0;
}

2.懒汉模式

#include<iostream>
using namespace std;

class singleton2{
private:
    int i;
    singleton2(int x) :i(x){}
    singleton2(const singleton2&);
    singleton2& operator=(singleton2&);
public:
    static singleton2& instance(){
        static singleton2 s(47);
        return s;
    }
    int getVal(){
        return i;
    }

    void setVal(int x){
        i = x;
    }
};


int main(){

    singleton2& s = singleton2::instance();
    cout << s.getVal() << endl;

    singleton2& s2 = singleton2::instance();
    s2.setVal(9);

    cout << s.getVal() << endl;

    return 0;
}

结果都是
47
9

3.线程安全

#include<iostream>
#include<mutex>
using namespace std;

class Lock{
private:
    mutex* mutexPtr;
public:
    Lock(mutex* pm) : mutexPtr(pm){
        mutexPtr->lock();
    }
    ~Lock(){
        mutexPtr->unlock();
    }
};

class singleton3{
private:
    int i;
    static mutex* m;//static
    static singleton3* pInstance;

    singleton3(int x) :i(x){}
    singleton3(const singleton3&);
    singleton3& operator=(singleton3&);
public:
    static singleton3* instance(){
        if (pInstance == NULL){
            Lock l(m);
            if (pInstance == NULL){
                pInstance = new singleton3(47);
            }
        }
        return pInstance;
    }
    void setVal(int x){
        i = x;
    }
    int getVal(){
        return i;
    }
};

singleton3* singleton3::pInstance = 0;
mutex* singleton3::m = new mutex();

int main(){

    singleton3* s = singleton3::instance();
    cout << s->getVal() << endl; 

    singleton3* s2 = singleton3::instance();
    s->setVal(9);

    cout << s->getVal() << endl;

    return 0;
}

之所以在Instantialize函数里面对pInstance 是否为空做了两次判断，因为该方法调用一次就产生了对象。

pInstance == NULL 大部分情况下都为false，如果按照原来的方法，每次获取实例都需要加锁，效率太低。
而改进的方法只需要在第一次调用的时候加锁，可大大提高效率。