C++：单例模式

单例模式的定义

确保某一个类只有一个实例， 而且自行实例化并向整个系统提供这个实例。

方法一:

static Singleton *getInstance()
    {
        static Singleton locla_s;
        return &locla_s;
    }

该代码可能在c++11之前的版本导致多次构造函数的调用，所以只能在较新的编译器上使用。

方法二:

static Singleton *getInstance()
    {
        pthread_mutex_lock(&mutex);
        if (local_instance == nullptr)
        {
            local_instance = new Singleton();
        }
        pthread_mutex_unlock(&mutex);
        return local_instance;
    }

下面这个版本使用了mutex以及静态成员来析构单例。该方案的劣处在于锁导致速度慢，效率低。但是至少是正确的，也能在c++11之前的版本使用。

方法三:

static Singleton *getInstance()
    {
        if(local_instance == nullptr){
            pthread_mutex_lock(&mutex);
            if (local_instance == nullptr)
            {
                local_instance = new Singleton();
            }
            pthread_mutex_unlock(&mutex);
        }
        return local_instance;
    }

使用双锁检查导致未初始化的内存访问

使用如下的代码来实现已经初始化的对象的直接返回。可以使上述代码性能会大大加快。但是相同的代码在Java下面有很明显的问题，由于CPU乱序执行，可能导致访问到未经初始化的对象的引用。c++也存在相同的问题，可能导致未定义行为导致段错误

假如线程A进入锁内并分配对象的空间，但是由于指令可能乱序，实际上导致local_instance被先指向一块未被分配的内存，然后再在这块内存上进程初始化。但是在指向后，未初始化前，另一线程B可能通过getInstance获取到这个指针。

方法四

在新的标准中，atomic类实现了内存栅栏，使得多个核心访问内存时可控。这利用了c++11的内存访问顺序可控。

#include <iostream>
#include <atomic>
#include <thread>
#include <mutex>

using namespace std;
class Singleton
{
private:
	static atomic<Singleton*> instance;

	class rememberFree {
	public:
		rememberFree() {}
		~rememberFree() {
			Singleton* local_instance = 
   instance.load(std::memory_order_relaxed);
			if (local_instance != nullptr) {
				delete local_instance;
			}
		}
	};
	static rememberFree remember;

public:
	static Singleton *getInstance()
	{
		Singleton* tmp = instance.load(std::memory_order_relaxed);
		atomic_thread_fence(memory_order_acquire);
		if (tmp == nullptr) {
			static mutex mtx;
			lock_guard<mutex> lock(mtx);
			tmp = instance.load(memory_order_relaxed);
			if (tmp == nullptr)
			{
				tmp = new Singleton();
				atomic_thread_fence(memory_order_release);
				instance.store(tmp, memory_order_relaxed);
			}
		}
		return tmp;
	}
};

atomic<Singleton*> Singleton::instance;
Singleton::rememberFree Singleton::remember;

int main()
{
	Singleton * s2 = Singleton::getInstance();
}

RAII方式同步线程锁

通过C++的这种机制，我们可以很方便地处理C++中的加锁同步机制。把锁对象作为Guard对象的一个成员(m_lock),然后在Guard对象的构造中对m_lock进行加锁:m_lock.acquire()，在Guard对象的析构函数中进行解锁:m_lock.release()

template <class T>
class Guard
{
public :
        Guard(const T & lock);
        virtual ~Guard();
private:
        const T & m_lock;
};
template <class T>
Guard<T>::Guard(const T & lock) :
        m_lock(lock)
{
        m_lock.acquire();
}
template <class T>
Guard<T>::~Guard()
{
    m_lock.release();
}
我们可以在应用程序中这样使用它：
 void testFunc(.....)
{
  Guard<MutexWrapper>  guard(mutex);
  ...
}