单例模式

定义：

保证一个类仅有一个实例，并提供一个实例的全局访问点

目的作用：

1、在某些特殊的软件系统中，为了保证逻辑正确和良好的效率，必须在系统中存在一个实例。
2、绕过常规的构造器，提供一种机制来保证一个类只有一个实例。

使用场景：

1、读取配置文件
2、频繁实例化并随后销毁时
3、频繁访问IO资源时，如各种数据的连接
4、创建对象时对资源的消耗过多并耗时，但是又经常要用到对象

UML结构：

四种单例模式：

1、饿汉式单例：将实例设置为static变量，当类进行装载时进行创建，且static只会被创建一次。以空间换时间并且线程安全
2、懒汉式单例：实现延迟加载，判断一个实例是否已存在，如不存在则进行创建。时间换空间，如果不加同步即不加锁会导致线程之间竞争从而引发线程安全
3、双锁型单例模式：进入单例方法后先检查实例是否存在，如不存在则进入下一同步块。然后再次检查实例是否存在，如不存在则在同步的情况下创建一个实例。上述过程中直须同步一次从而到达了节省时间。
4、线程安全型单例模式：

代码：

```c++
#include <iostream>
#include <mutex>
#include <thread>
#include <chrono>
#include <atomic>


using namespace std;

#define SWITCH 6

// =default: 用于显式要求编译器提供合成版本的四大函数(构造、拷贝、析构、赋值)
/* =delete: 用于定义删除函数，在旧标准下，我们如果希望阻止拷贝可以通过显式声明
            拷贝构造函数和拷贝赋值函数为private，但新标准下允许我们定义删除函数*/



#if SWITCH == 1     //饿汉式单例模式
class Singleton
{
 public:
    static Singleton *getInstance()
    {
        static Singleton _singleton;
        return &_singleton;
    }
 private:
    Singleton() = default;
    Singleton(const Singleton& s) = delete;
    Singleton& operator=(const Singleton& s) = delete;
};

#elif SWITCH == 2     //饿汉式单例模式,但是构造在main函数初始化时，保证安全
class Singleton
{
 public:
    static Singleton *getInstance()
    {
        return &m_singleton;
    }
 private:
    static Singleton m_singleton;
    Singleton()
    {

        cout << "Singleton constructor!" << endl;
    }
    Singleton(const Singleton& s) = delete;
    Singleton& operator=(const Singleton& s) = delete;
};
Singleton Singleton::m_singleton;


#elif SWITCH == 3   //原始懒汉式单例模式
class Singleton
{
 public:
    static Singleton *getInstance()
    {
        if(Singleton::_singleton == nullptr)
        {
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
            _singleton = new Singleton();
        }
        return _singleton;
    }

 private:
    static Singleton *_singleton;
    Singleton() = default;
    Singleton(const Singleton& s) = delete;
    Singleton& operator=(const Singleton& s) = delete;

    class GarbageCollector
    {
     public:
        ~GarbageCollector()
        {
            cout << "~GarbageCollector" << endl;

            if(Singleton::_singleton)
            {
                cout << "free _singleton" << endl;
                delete Singleton::_singleton;
                Singleton::_singleton = nullptr;
            }
        }
    };

    static GarbageCollector m_gc;
};

Singleton *Singleton::_singleton = nullptr;
Singleton::GarbageCollector Singleton::m_gc;



#elif SWITCH == 4       //线程安全的懒汉单例模式
class Singleton
{
 public:
    static Singleton *getInstance()
    {
        m_mutex.lock();                     //加锁保证线程安全
        if(Singleton::_singleton == nullptr)
        {
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
            _singleton = new Singleton();
        }
        m_mutex.unlock();                   解锁
        return _singleton;
    }

 private:
    static Singleton *_singleton;
    static mutex m_mutex;
    Singleton() = default;
    Singleton(const Singleton& s) = delete;
    Singleton& operator=(const Singleton& s) = delete;

    class GarbageCollector
    {
     public:
        ~GarbageCollector()
        {
            cout << "~GarbageCollector" << endl;

            if(Singleton::_singleton)
            {
                cout << "free _singleton" << endl;
                delete Singleton::_singleton;
                Singleton::_singleton = nullptr;
            }
        }
    };

    static GarbageCollector m_gc;
    
};

Singleton *Singleton::_singleton = nullptr;
Singleton::GarbageCollector Singleton::m_gc;
mutex Singleton::m_mutex;



#elif SWITCH == 5       //双锁型单例
class Singleton
{
 public:
    static Singleton *getInstance()
    {
        if(Singleton::_singleton == nullptr)
        {
            m_mutex.unlock();
            if(Singleton::_singleton == nullptr)
            {
                std::this_thread::sleep_for(std::chrono::milliseconds(10));
                _singleton = new Singleton();
            }
            m_mutex.unlock();                   //解锁
        }
        return _singleton;
    }

 private:
    static Singleton *_singleton;
    static mutex m_mutex;
    Singleton() = default;
    Singleton(const Singleton& s) = delete;
    Singleton& operator=(const Singleton& s) = delete;

    class GarbageCollector
    {
     public:
        ~GarbageCollector()
        {
            cout << "~GarbageCollector" << endl;

            if(Singleton::_singleton)
            {
                cout << "free _singleton" << endl;
                delete Singleton::_singleton;
                Singleton::_singleton = nullptr;
            }
        }
    };

    static GarbageCollector m_gc;
    
};
Singleton *Singleton::_singleton = nullptr;
Singleton::GarbageCollector Singleton::m_gc;
mutex Singleton::m_mutex;

#elif SWITCH == 6       //原
class Singleton
{
 public:
    void *getSingletonAddress()
    {
        return m_instance;
    }
    static Singleton *getInstance()
    {
        Singleton *tmp = m_instance.load(std::memory_order_relaxed);    //为给定原子操作定义内存排序约束
        std::atomic_thread_fence(std::memory_order_acquire);
        if(tmp == nullptr)
        {
            std::lock_guard<std::mutex> lock(m_mutex);
            tmp = m_instance.load(std::memory_order_relaxed);
            if(tmp == nullptr)
            {
                tmp = new Singleton();
                std::atomic_thread_fence(std::memory_order_release);
                m_instance.store(tmp, std::memory_order_relaxed);
            }
        }
        return tmp;
    }
 private:
    static std::atomic<Singleton *> m_instance;
    static std::mutex m_mutex;
    Singleton() = default;
    Singleton(const Singleton& s) = default;
    Singleton& operator=(const Singleton& s) = default;

    class GarbageCollector
    {
    public:
        ~GarbageCollector()
        {
            cout << "~GarbageCollector" << endl;

            Singleton *tmp = m_instance.load(std::memory_order_relaxed);
            if(tmp)
            {
                cout << "free _singleton" << endl;
                delete tmp;
            }
        }
    };

    static GarbageCollector m_gc;
};

std::atomic<Singleton *> Singleton::m_instance;
Singleton::GarbageCollector Singleton::m_gc;
std::mutex Singleton::m_mutex;

#endif

static mutex single_lock;

void print_address()
{
    Singleton *singleton = Singleton::getInstance();

    single_lock.lock();

    cout << singleton << endl;

    single_lock.unlock();
}


void thread_Singleton()
{
    thread threads[10];

    for(auto&t : threads)
    {
        t = thread(print_address);
    }

    for(auto&t : threads)
    {
        t.join();
    }
}

int main()
{
    thread_Singleton();

    cout << endl << Singleton::getInstance() << endl;
}
```