设计模式（二）之单例模式

在整个软件系统中，某个类智能存在一个对象实例，并且该类只提供一个获取对象实例的方法。

单例模式有8种方式：

1.饿汉式（静态常量）

请注意这行代码，在类装在的时候已经实例化了。这样来避免构造类的时候线程同步的问题

但是这样也会造成内存浪费的问题，因为及时不使用的时候也会去构造这个类。

Singleton * Singleton::single = new Singleton;

class Singleton
{
public :
    static Singleton* GetSingleton(void);
private:
    Singleton();
    static Singleton* single ;
 
};

Singleton::Singleton(){
    qDebug() << "Creat Singleton start" << endl;
    sleep(1);
    qDebug() << "Creat Singleton end" << endl;
}
Singleton* Singleton::GetSingleton(void){
    qDebug() << "single = " <<single<< endl;
    return single;
}
 
Singleton * Singleton::single = new Singleton;

2.饿汉式2

class Singleton
{
public :
    static Singleton* GetSingleton(void);
private:
    Singleton();
};

Singleton::Singleton(){
    qDebug() << "Creat Singleton start" << endl;
    sleep(1);
    qDebug() << "Creat Singleton end" << endl;
}
Singleton* Singleton::GetSingleton(void){
    static Singleton s_instance;
    qDebug() << "single = " <<&s_instance<< endl;
    return &s_instance;
}

3.懒汉式（线程不安全，不可使用）

优点：使用的时候才去构建类

缺点：多线程的时候会产生多个实例。假如构造函数要用10秒来完成，那么多线程就会导致多个实例产生。

class Singleton
{
public :
    static Singleton* GetSingleton(void);
private:
    Singleton();
    static Singleton* single ;
};

Singleton::Singleton(){
    qDebug() << "Creat Singleton start" << endl;
    sleep(1);
    qDebug() << "Creat Singleton end" << endl;
}
Singleton* Singleton::GetSingleton(void){
    qDebug() << "single = " <<single<< endl;
    if(single == nullptr){
        single = new Singleton;
    }
    return single;
}
Singleton * Singleton::single = nullptr;

4.懒汉式（线程安全 DoubleCheck）

两次检查配合线程同步来实现单例模式

class Singleton
{
public :
    static Singleton* GetSingleton(void);
private:
    Singleton();
    static Singleton* single ;
    static QMutex mutex;
 
};

Singleton::Singleton(){
    qDebug() << "Creat Singleton start" << endl;
    sleep(1);
    qDebug() << "Creat Singleton end" << endl;
}
Singleton* Singleton::GetSingleton(void){
    if(single == nullptr){
        mutex.lock();
        if(single == nullptr){
            single = new Singleton;
        }
        mutex.unlock();
    }
    return single;
}
 
Singleton * Singleton::single = nullptr;
QMutex Singleton::mutex;

这里使用的双检查锁的方式看似安全，程序reorder会让这个方式并不安全

当A线程执行到single = new Singleton;这一行代码的时候。

假设这一行代码需要完成下面的三件事

1. 分配内存
2. 构造器构造这个类
3. 内存的地址复制给single

我们理想中是按照这样一个顺序去执行的。但是实际情况下往往不是这样的。CPU或者编译器为了提升效率。会对指令进行reorder，或者说在不影响结果的情况下同时执行部分指令。有可能会是下面的顺序

1. 分配内存
2. 内存地址复制给sigle
3. 构造器构造这个类（假设这里构造需要的时间比较长）

假如A线程执行到第2步骤 或者对象地址的时候，线程B执行到if(single == nullptr) ，那么会判断为这个对象已经有了。接下来B线程就会使用这个对象了。但实际情况下这个对象还没有被构造完成。这样就会导致程序出错。

single = new Singleton;的反汇编
0x401d7b  <+0x0047>        bf 01 00 00 00              mov    $0x1,%edi
0x401d80  <+0x004c>        e8 db f4 ff ff              callq  0x401260 <_Znwm@plt>
0x401d85  <+0x0051>        48 89 c3                    mov    %rax,%rbx
0x401d88  <+0x0054>        48 89 df                    mov    %rbx,%rdi
0x401d8b  <+0x0057>        e8 60 fe ff ff              callq  0x401bf0 <Singleton::Singleton()>
0x401d90  <+0x005c>        48 8d 05 71 13 20 00        lea    0x201371(%rip),%rax        # 0x603108 <_ZN9Singleton6singleE>
0x401d97  <+0x0063>        48 89 18                    mov    %rbx,(%rax)

解决方案如下图所示