单例模式

单例模式一般用于全局只需要一个唯一的实例的情况。

例如说，日志读写的功能，一般来说全局只需一个日志读写实例，然后其他的类实例去获取这个实例进行日志读写。

又例如说，有一个协作的功能，需要各个模块发送给主控制器，主控制器需要做成单例，这样子模块之间操作控制器就是操作实际主控制器的内容。

怎么写一个单例模式

C语言编写一个单例模式

先从最简单的C语言开始，一般我们说到单例模式是指面向对象的单例模式，因为一个类生成一个实例对象就是单例模式。

那么落到C语言，就是结构体了，我们用结构体创建单个实例。

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef struct _Data {
    void* pData;
    int value;
} Data;

void* GetData() {
    static Data* pData = NULL;
    if(NULL != pData) {
        return pData;
    }
    pData = (Data*)malloc(sizeof(Data));
    assert(NULL != pData);
    pData->value = 0;  /* init */
    return (void*)pData;
}

void FreeData() {
    Data* pd = GetData();
    if(NULL != pd) {
        free(pd);
        pd = NULL;
    }
}

int main() {
    Data* pdata0 = GetData();
    pdata0->value = 0;
    Data* pdata1 = GetData();
    pdata1->value = 100;
    printf("value: %d\n", pdata0->value);
    FreeData();
}

那么我们看以上代码，有两个函数GetData和FreeData，看GetData，这里面就是我们常见的懒汉模式，只有到需要用的时候才去创建实例。

在上面GetData中，如果是第一次进入到函数时pData是NULL，此时会申请一片内存空间，并且如果value需要初始化，也可以在这里进行。到了第二次调用这个函数之后，就直接返回原来的变量了，因为变量保存在静态区，所以每次返回的都是同一实例。这样就实现了懒汉式的单例模式。

用C++写一个单例模式

最经典的单例模式是SingletonMeyer's，这种单例模式由Scott Meyers 在 《Effective C++》中提出。也就是我们常见的C++的懒汉式单例模式。代码如下：

#include <iostream>
//using namespace std;
using std::cout;
using std::endl;

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton s_singleton;  /* 永远只能获取这个变量，因为传递出去的是引用 */
        return s_singleton;
    }
    void SetValue(int value) {
        this->m_value_ = value;
    }
    int GetValue() {
        return this->m_value_;
    }
private:
    int m_value_;
    Singleton() {
        SetValue(0);
    };
    ~Singleton() {};
    Singleton(const Singleton&) = delete;  /* 禁止复制构造 */
    Singleton& operator=(const Singleton&)= delete;  /* 禁止复制构造 */
};

int main() {
    Singleton& a = Singleton::getInstance();
    cout<<"a value is "<<a.GetValue()<<endl;
    Singleton& b = Singleton::getInstance();
    cout<<"b value is "<<b.GetValue()<<endl;

    cout<<"change a value to 50"<<endl;
    a.SetValue(50);
    cout<<"b value is "<<b.GetValue()<<endl;
    return 0;
}

如上，我们将构造函数放到私有，这样就只能通过getInstance来构造

然后我们，在初次调用getInstance的时候创建实例，并返回引用。这样就实现了一种懒汉式的单例模式。

然后后续的getInstance获取到的都会是第一次申请的Singleton对象

在main函数中，我们先打印两个引用的value，两个值都是0，然后我们改变其中一个引用的value，这个时候另外一个引用的value也发生了改变，因为这两个引用指向的是同一个实例。

a value is 0
b value is 0
change a value to 50
b value is 50

用C++写另一种单例模式

另外一种单例模式，就是饿汉式。

#include <iostream>
using std::cout;
using std::endl;

class Singleton {
public:
    static Singleton& getInstance() {
        return m_singleton_;
    }
    void SetValue(int value) {
        this->m_value_ = value;
    }
    int GetValue() {
        return this->m_value_;
    }
private:
    static Singleton m_singleton_;
    int m_value_;
    Singleton() {
        SetValue(0);
    }
    ~Singleton() {};
    Singleton(const Singleton&) = delete;  /* 禁止复制构造 */
    Singleton& operator=(const Singleton&)= delete;  /* 禁止复制构造 */
};
Singleton Singleton::m_singleton_;  /* 静态成员类外初始化 */

int main() {
    Singleton& a = Singleton::getInstance();
    cout<<"a value is "<<a.GetValue()<<endl;
    Singleton& b = Singleton::getInstance();
    cout<<"b value is "<<b.GetValue()<<endl;

    cout<<"change a value to 50"<<endl;
    a.SetValue(50);
    cout<<"b value is "<<b.GetValue()<<endl;
    return 0;
}

饿汉式和懒汉式唯一不同的是，本来在函数的静态成员变成了类成员变量。

这样就导致这个成员在类创建的时候就已经生成了实例。也就是所谓的饿汉式，先把东西都准备好，然后需要的时候直接返回就好

上面代码的的main函数没有任何改动，就是演示两个引用指向的是同一实例。

线程安全？

看了懒汉式和饿汉式的，我们大概可以知道，饿汉式的是线程安全的，因为它在类加载时已经完成对实例的初始化了

而懒汉式只在第一次访问的时候才进行初始化，这样会导致多条线程同时是第一次访问的时候，实例创建了多次。

那么怎么保证懒汉式线程安全呢，加锁就可以了。

在第一次访问时判断是否有加锁，这里具体代码就不演示了。