簡單理解

單例模式是指進程生命期內，某個類型只實例化一個對象。這是一種通過語言特性實現的編程約束。如果沒有約束，那麽多人協同編碼時，就會出現非預期的情況。

下面以內存池做例子，假設其類型名為MemoryPool。內存池的本意是統一管理全局內存，優化內存分配，提升性能，記錄內存分配信息方便追溯問題，需要全局只有一個實例對象。

第一階段：沒有任何約束

因為沒有任何約束，大家會各自實例化MemoryPool對象來使用。最終一片混亂，根本達不到最初使用內存池的目的。

第二階段：編程語言外的約束

在MemoryPool處添加註釋，告訴大家只能使用一個MemoryPool的全局變量。剛開始還挺好，但總會有一些人不知道為什麽就自己實例化MemoryPool

第三階段：編程語言的約束

將MemoryPool的構造函數、拷貝構造函數、賦值構造函數都設為私有，只允許使用者通過一個接口來獲取MemoryPool對象。當有人想自己實例化MemoryPool對象來使用時，編譯就會報錯。接口內只返回固定的一個已實例化的對象，完美！

實現

單例一般有兩種方式

• 程序初始化階段時構造單例對象：進入main()之前構造，沒有多線程問題，但不論是否使用都占用了資源
• 使用時才構造單例對象：使用時才占用資源，但需要註意多線程競爭問題

以下是C++實現的單例代碼
Singletion.h

#ifndef __SINGLETON_H__
#define __SINGLETON_H__

#include <mutex>

/**
 * @brief 單例模板
 * @detail 使用單例模式的類型需要將該模板設為友元類
 */
template<typename T>
class Singleton
{
public:
    static T* instance()
    {
        std::call_once( m_once, [](){ m_instance = new T; } );
        return m_instance;
    }

    static void destroy()   
    {
        if( NULL != m_instance ){
            delete m_instance;
            m_instance = NULL;
        }
        return;
    }
private:
    static T* m_instance;
    static std::once_flag m_once;
};
template<typename T>
T* Singleton<T>::m_instance = NULL;

template<typename T>
std::once_flag Singleton<T>::m_once;

#endif
 

std::call_once()在Linux平臺調用的是pthread_once()。flag有三個狀態NEVER（0）、IN_PROGRESS（1）、DONE（2），其中使用了兩個帶LOCK前綴的指令：cmpxchg和incl。lock cmpxchg 將flag從0變為1，lock incl將flag從1變為2。lock鎖定特定內存地址，避免其他CPU讀取或者修改這個內存地址的值。

Adder.h

#ifndef __ADDER_H__
#define __ADDER_H__

#include "Singleton.h"
#include <atomic>

/**
 * @brief 累加器
 * @detail 使用單例模式，全局累加器
 */
class Adder
{
    friend class Singleton<Adder>;
public:
    Adder& operator<<(int32_t n)
    {
        m_num += n;
        return *this;
    }
    
    int32_t value()
    {
        return m_num;
    }
private:
    Adder()
    {
    }
    Adder(Adder&);
    Adder& operator=(Adder&);

private:
     std::atomic<int32_t> m_num;
};

#endif
 

main.cpp

#include "Adder.h"

#include <thread>
#include <vector>
#include <iostream>
void worker()
{
    int i = 1000000;
    while( i-- ){
        *(Singleton<Adder>::instance()) << 1;   
    }
    return;
}
int main()
{
    std::vector<std::thread> threads;
    for( int i = 0; i < 10; ++i ){
        std::thread t( worker );
        threads.push_back( std::move( t ) );
    }
    
    for( int i = 0; i < 10; ++i ){
        threads[i].join();
    }
    // 輸出等於1000萬
    std::cout << Singleton<Adder>::instance()->value() << std::endl;
    return 0;
}

設計模式的簡單理解——單例模式