c++之线程安全的跨平台的单例模式

最新推荐文章于 2023-06-16 21:52:01 发布

yunshouhu

最新推荐文章于 2023-06-16 21:52:01 发布

阅读量837

点赞数

分类专栏： c/c++

本文链接：https://blog.csdn.net/earbao/article/details/44219073

版权

c/c++ 专栏收录该内容

364 篇文章 15 订阅

订阅专栏

Singleton模式是最常用的设计之一，最近结合自己的实际应用，把Singleton作为模板抽象出来（线程安全），权当抛砖引用，欢迎大家提出批评意见，互相交流。下面为源码，已经编译运行过。

#ifndef _Singleton_h_
#define _Singleton_h_

#include <pthread.h>

//信号锁  保证线程安全
class Mutex
{
public:
	Mutex()
	{
		pthread_mutex_init(&m_lock,NULL);
	}

	~Mutex()
	{
		pthread_mutex_destroy(&m_lock);
	}

	void Lock()
	{
		pthread_mutex_lock(&m_lock);
	}

	void UnLock()
	{
		pthread_mutex_unlock(&m_lock);
	}

private:
	pthread_mutex_t m_lock;
};

template<class T>
class Singleton
{
public:
	static T*    GetInstance();
	static void  Destroy();
private:
	static T*    m_pInstance;
	static Mutex m_mutex;
};

template<class T>
T* Singleton<T>::m_pInstance = 0;

template<class T>
Mutex Singleton<T>::m_mutex;

template<class T>
T* Singleton<T>::GetInstance()
{
	if (m_pInstance)
	{
		return m_pInstance;
	}
	m_mutex.Lock();
	if (NULL == m_pInstance)
	{
		m_pInstance = new T;
	}
	m_mutex.UnLock();
	return m_pInstance;
}

template<class T>
void Singleton<T>::Destroy()
{
	if (m_pInstance)
	{
		delete m_pInstance;
		m_pInstance= NULL;
	}
}

#endif

#include "Singleton.h"
#include <iostream>
using namespace std;

class Testclass
{
public:
	void Run ()
	{
		cout<<"Hi, Testclass run.\n";
	}
private:
	friend class Singleton<Testclass>;
	Testclass()  {};
	~Testclass() {};
	Testclass(const Testclass& ref);
	Testclass& operator=(const Testclass& ref);
};

typedef Singleton<Testclass> SingleTestclass;

int main(int argc,char* argv[])
{
	Testclass* pInstance = SingleTestclass::GetInstance();
	pInstance->Run();
	
	return 0;
}

http://blog.csdn.net/yasaken/article/details/7284871

c++之线程安全的跨平台的单例模式

#ifndef _Singleton_h_
#define _Singleton_h_

#if _WIN32
#include <Windows.h>

class MutexLock
{  
private:         
	CRITICAL_SECTION m_cs;
public:  
	MutexLock()
	{
		//InitializeCriticalSectionAndSpinCount(&m_cs, 0x00000400);
		InitializeCriticalSection(&m_cs);
	}

	~MutexLock()
	{
		DeleteCriticalSection(&m_cs);
	}

	void Lock()
	{
		EnterCriticalSection(&m_cs);
	}

	void UnLock()
	{
		LeaveCriticalSection(&m_cs);
	}
};  

#else
#include <pthread.h>
//信号锁  保证线程安全
class MutexLock
{
public:
	MutexLock()
	{
		pthread_mutex_init(&m_lock, NULL);
	}

	~MutexLock()
	{
		pthread_mutex_destroy(&m_lock);
	}

	void Lock()
	{
		pthread_mutex_lock(&m_lock);
	}

	void UnLock()
	{
		pthread_mutex_unlock(&m_lock);
	}

private:
	pthread_mutex_t m_lock;
};
#endif

template<class T>
class Singleton
{
public:
	static T*    GetInstance();
	static void  Destroy();
private:
	static T*    m_pInstance;
	static MutexLock m_mutex;
};

template<class T>
T* Singleton<T>::m_pInstance = 0;

template<class T>
MutexLock Singleton<T>::m_mutex;

template<class T>
T* Singleton<T>::GetInstance()
{
	if (m_pInstance == NULL)
	{   //double check  
		m_mutex.Lock();
		if (m_pInstance == NULL)
		{
			m_pInstance = new T();
		}
		m_mutex.UnLock();
	}
	return m_pInstance;
}

template<class T>
void Singleton<T>::Destroy()
{
	if (m_pInstance)
	{
		delete m_pInstance;
		m_pInstance = NULL;
	}
}

#endif

#include "Singleton.h"
#include <iostream>
//#include <vld.h>
using namespace std;

class Testclass
{
public:
	void Run()
	{
		cout << "Hi, Testclass run.\n";
	}
	//delete 
	~Testclass() {

	};
private:
	friend class Singleton<Testclass>;
	Testclass()  {};
	
	Testclass(const Testclass& ref);
	Testclass& operator=(const Testclass& ref);
};

typedef Singleton<Testclass> SingleTestclass;

//c++之线程安全的跨平台的单例模式
int main(int argc, char* argv[])
{
	Testclass* pInstance = SingleTestclass::GetInstance();
	pInstance->Run();

	//解决了内存泄漏
	delete pInstance;
	return 0;
}