设计模式:单例模式

单例模式

应用场景

当类的实例只能有一个时，使用单例模式

懒汉模式

懒汉模式指在第一次获取实例时，才对实例进行初始化

//线程不安全的懒汉模式
class SingleTon {
private:
    //静态成员变量，类内声明，类外初始化
    static SingleTon* instance;
    //构造函数私有化
    SingleTon(){}
    SingleTon(const SingleTon& tmp) {}
    SingleTon& operator = (const SingleTon& tmp) {}

public:
    //对外接口，获取单例
    static SingleTon* getInstance() {
        if (instance == nullptr) instance = new SingleTon();
        return instance;
    }
};
SingleTon* SingleTon::instance = nullptr;

懒汉模式是线程不安全的，因为会有多个线程进入if(instance == nullptr) 的分支

有两种解决方法：

方法一：使用mutex锁

//线程安全的懒汉模式
class SingleTon {
private:
    //静态成员变量，类内声明，类外初始化
    static SingleTon* instance;
    static pthread_mutex_t mutex;
    //构造函数私有化
    SingleTon(){}
    SingleTon(const SingleTon& tmp) {}
    SingleTon& operator = (const SingleTon& tmp) {}

public:
    //对外接口，获取单例
    static SingleTon* getInstance() {
        //多一层判断，提高并发性能
        if (instance == nullptr) {
            //加锁保证原子性
            pthread_mutex_lock(&mutex);
            if (instance == nullptr) instance = new SingleTon();
            pthread_mutex_unlock(&mutex);
        }
        return instance;
    }
};
SingleTon* SingleTon::instance = nullptr;
pthread_mutex_t SingleTon::mutex;

方法二：使用静态局部变量

//线程安全的懒汉模式
class SingleTon {
private:
    //构造函数私有化
    SingleTon(){}
    SingleTon(const SingleTon& tmp) {}
    SingleTon& operator = (const SingleTon& tmp) {}

public:
    //对外接口，获取单例
    static SingleTon* getInstance() {
        //静态局部变量，只初始化一次，并且static是线程安全的
        static SingleTon instance;
        return &instance;
    }
};

饿汉模式

饿汉模式在类外进行实例的初始化

//线程安全的饿汉模式
class SingleTon {
private:
    //静态成员变量，类内声明，类外初始化
    static SingleTon* instance;
    //构造函数私有化
    SingleTon(){}
    SingleTon(const SingleTon& tmp) {}
    SingleTon& operator = (const SingleTon& tmp) {}

public:
    //对外接口，获取单例
    static SingleTon* getInstance() {
        return instance;
    }
};
SingleTon* SingleTon::instance = new SingleTon();