设计模式之单例模式

单例模式是在使用类时，只会实例化出一个对象。

实现单例模式有两种方式：1. 懒汉模式 2. 饿汉模式。

懒汉模式指的是只有当需要使用到对象时才会取实例化，而饿汉模式则是一开始就实例化出对象。

• 懒汉模式

class SingleInstan{
    static SingleInstan* instance;
    SingleInstan(){}
    SingleInstan(SingleInstan &a)=delete;      
public:
    SingleIntan* getInstan(){
        if(instance==NULL){
            instance=new SingleInstan();
        }
        return instance;
    }
};
SingleInstan::instance=NULL;

其中构造函数为私有，并且禁止默认拷贝构造函数生成，获取对象只能通过getInsta()。

• 饿汉模式

class SingleInstan{
    static SingleInstan *instance;
    SingleInstan(){}
    SingleInstan(SingleInstan &a)=delete;
public:
    static getInstan(){
        return instance;
    }
};
SingleInstan::instance=new SingleInstan();

直接实例化对象。

上述中的懒汉模式是多线程不安全的一个实现。

如何实现一个线程安全的单例模式呢？我们有两种方式。

struct Lock{
    pthread_mutex_t mutex;
    Lock(){
        pthread_mutex_init(&mutex);
    }
};
class SingleInstan{
    static SingleInstan *instance;
    SingleInstan(){}
    SingleInstan(SingleInstan &a)=delete;
public:
    static SingleInstan* getInstan(Lock lock){
        pthread_mutex_lock(&(lock.mutex));
        if(instance==NULL){
            instance=new SingleInstan();
         }
        pthread_mutex_unlock(&(lock.mutex));
        return instance;
    }
};

这里用到一个互斥锁来保证线程安全，而且只用了一层判断，其实可以外面再加一层if(instance==NULL)的判断，可以优化性能。

另一种是使用局部静态变量，非常简洁

class SingleInstan{
    SingleInstan(){}
    SingleInstan(const SingleInstan &a=delete;
public:
    static SingleInstan& getInstan(){
        static SingleInstan instance();
        return instance;
    }
};