c++ 设计模式 (二) - 单例模式

---

单例模式实现方法

通过单例模式保证系统中一个类只有一个实例，实现方法：

1. 设置构造函数，拷贝构造函数，赋值运算符函数均为私有函数
2. 定义一个该类的静态私有对象
3. 定义一个静态公有函数，用于创建和获取其静态私有对象

一、饿汉模式

饿了就立刻想到吃，类比到创建对象也是如此，当类一初始化，该对象就立刻会被实例化

#include <stdio.h>
#include <unistd.h>

class Singleton
{
public:
    static Singleton* GetInstance()
    {
        return m_singleton;
    }
    
private:
    Singleton() {};
    Singleton(const Singleton& singleton) {};
    Singleton& operator=(const Singleton& singleton) {};
    static Singleton* m_singleton;
};

Singleton* Singleton::m_singleton = new Singleton( );

int main()
{
    Singleton *sp1 = Singleton::GetInstance();
    Singleton *sp2 = Singleton::GetInstance();
    printf("sp1 = 0x%08X\n", sp1); // sp1 = 0x016A3010
    printf("sp2 = 0x%08X\n", sp2); // sp2 = 0x016A3010
    return 0;
}

static 修饰的成员属于类，在类加载阶段就已经被加载，并且只能被加载一次，这种特性很好的保证了单例的特性，并且天然支持多线程
缺陷：一旦类加载时就会创建成员对象，大部分情况下没啥问题，但是如果创建这个对象极其耗费时间和资源呢？这样必然会造成巨大的性能损耗

二、懒汉模式

和饿汉相反，能不吃就不吃饭，等到实在饿得不行了（需要用该对象了）才去吃饭（创建对象）

#include <stdio.h>
#include <unistd.h>

class Singleton
{
public:
    static Singleton* GetInstance()
    {
        if (NULL == Singleton::m_singleton)
        {
            m_singleton = new Singleton();
        }
        return m_singleton;
    }
    
private:
    Singleton() {};
    Singleton(const Singleton& singleton) {};
    Singleton& operator=(const Singleton& singleton) {};
    static Singleton* m_singleton;
};

Singleton* Singleton::m_singleton = NULL;

int main()
{
    Singleton *sp1 = Singleton::GetInstance();
    Singleton *sp2 = Singleton::GetInstance();
    printf("sp1 = 0x%08X\n", sp1); // sp1 = 0x016A3010
    printf("sp2 = 0x%08X\n", sp2); // sp2 = 0x016A3010
    return 0;
}

该模式既实现了延迟加载，节约资源，又保证了单例，貌似没毛病
没错，在单线程下面确实如此，可惜在多线程下有问题。假如有两个线程A和B同时到达if处，然后都会调用 m_singleton = new Singleton(); 从而创建多个对象

三、懒汉模式，使用互斥锁解决多线程问题

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

pthread_mutex_t mutex;

class Singleton
{
public:
    static Singleton* GetInstance()
    {
        pthread_mutex_lock(&mutex);
        if (NULL == Singleton::m_singleton)
        {
            m_singleton = new Singleton();
        }
        pthread_mutex_unlock(&mutex);
        return m_singleton;
    }
    
private:
    Singleton() {};
    Singleton(const Singleton& singleton) {};
    Singleton& operator=(const Singleton& singleton) {};
    static Singleton* m_singleton;
};

Singleton* Singleton::m_singleton = NULL;

int main()
{
    pthread_mutex_init(&mutex, NULL);
    Singleton *sp1 = Singleton::GetInstance();
    Singleton *sp2 = Singleton::GetInstance();
    printf("sp1 = 0x%08X\n", sp1); // sp1 = 0x016A3010
    printf("sp2 = 0x%08X\n", sp2); // sp2 = 0x016A3010
    pthread_mutex_destroy(&mutex);
    return 0;
}

该方案实现了延迟加载，也实现了多线程单例，但是效率不高：

1. 锁操作耗时多，影响性能
2. 每个线程不管instance有没有被创建过，都会先获取互斥量在进入 if 分支，由于同一时刻只会有一个线程进入，其余线程都必须等待，这就会导致线程阻塞，性能下降

四、懒汉模式，使用双重检测互斥锁

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

pthread_mutex_t mutex;

class Singleton
{
public:
    static Singleton* GetInstance()
    {
        if (NULL == Singleton::m_singleton)
        {
            pthread_mutex_lock(&mutex);
            if (NULL == Singleton::m_singleton)
            {
                m_singleton = new Singleton();
            }
            pthread_mutex_unlock(&mutex);
        }
        return m_singleton;
    }
    
private:
    Singleton() {};
    Singleton(const Singleton& singleton) {};
    Singleton& operator=(const Singleton& singleton) {};
    static Singleton* m_singleton;
};

Singleton* Singleton::m_singleton = NULL;

int main()
{
    pthread_mutex_init(&mutex, NULL);
    Singleton *sp1 = Singleton::GetInstance();
    Singleton *sp2 = Singleton::GetInstance();
    printf("sp1 = 0x%08X\n", sp1); // sp1 = 0x016A3010
    printf("sp2 = 0x%08X\n", sp2); // sp2 = 0x016A3010
    pthread_mutex_destroy(&mutex);
    return 0;
}

该方案使用了两次 if 分支判断，作用不同：
第一次为了提高效率：回顾懒汉方案，将整个方法加锁，这样不管其它线程在调用该方法这一时刻该对象是否已经被创建好，都需要阻塞等待。而此处的if判断就使得，只有此时真的还没有创建出对象才会进入加锁代码块，如果已经创建了就直接 return，所以显然提高了效率
第二次才是用来保证多线程单例的：如果没有第二个 if 分支，此时两个线程A和B都在等待互斥锁资源，A线程先获取互斥锁，然后创建对象释放互斥锁后返回，此时B线程获取互斥锁，接着又会创建对象，则破坏了单例实现
缺点：仍然避免不了锁操作，对性能仍然有影响

五、内部类方式

根据类加载机制，外部类的初始化并不会导致内部类的初始化，根据类的静态成员只初始化一次，天然支持多线程

#include <stdio.h>
#include <unistd.h>

class Singleton
{
public:
    static Singleton* GetInstance()
    {
        return Inner::m_singleton;
    }
    private: class Inner
    {
    public:
        static Singleton* m_singleton;
    };
    
private:
    Singleton() {};
    Singleton(const Singleton& singleton) {};
    Singleton& operator=(const Singleton& singleton) {};
};

Singleton* Singleton::Inner::m_singleton = new Singleton();

int main()
{
    Singleton *sp1 = Singleton::GetInstance();
    Singleton *sp2 = Singleton::GetInstance();
    printf("sp1 = 0x%08X\n", sp1); // sp1 = 0x016A3010
    printf("sp2 = 0x%08X\n", sp2); // sp2 = 0x016A3010
    // printf("m_singleton = 0x%08X\n", Singleton::Inner::m_singleton);
    // innerDemo2.cpp:11:20: error: ‘class Singleton::Inner’ is private
    return 0;
}

Inner 是一个内部类，内部静态字段 m_singleton 负责创建对象。当外部类 Singleton 初始化时，并不会导致 Inner 初始化，从而实现了延迟加载
当外部调用 GetInstance() 时，通过 Inner::m_singleton 对对象引用才会导致对象的创建，由于 static 的属性只会跟随类加载初始化一次，天然保证了线程安全问题
此方案实现了延迟加载的功能，同时避免了锁操作带来的性能影响，是个相对完美的方案