一、返回指针,饱汉式:
singleton.h
#ifndef __CC_SINGLETON_H__
#define __CC_SINGLETON_H__
#include <iostream>
#include <mutex>
using std::cout;
using std::endl;
namespace cc
{
class Singleton
{
public:
static Singleton * getInstance();
static void destroyInstance();
private:
Singleton(){cout << "Singleton()" << endl;}
~Singleton(){cout << "~Singleton()" << endl;}
//禁止复制
Singleton(const Singleton &) = delete;
Singleton & operator=(const Singleton &) = delete;
private:
static std::mutex m_mutex;
static Singleton * m_pInstance;
};
Singleton* Singleton::m_pInstance = nullptr;
std::mutex Singleton::m_mutex;
Singleton* Singleton::getInstance(){
if(nullptr == m_pInstance){
std::lock_guard<std::mutex> guard(m_mutex);
if(nullptr == m_pInstance){
m_pInstance = new Singleton();
}
}
return m_pInstance;
}
void Singleton::destroyInstance(){
if(m_pInstance != nullptr){
delete m_pInstance;
m_pInstance = nullptr;
}
}
}//end of namespace
#endif
test.cc
#include "singleton.h"
#include "stdio.h"
#include <iostream>
using std::cout;
using std::endl;
using namespace cc;
int main(){
cout << "......begin......" << endl;
Singleton *p1 = Singleton::getInstance();
Singleton *p2 = Singleton::getInstance();
Singleton *p3 = Singleton::getInstance();
printf("p1 = %p\n",p1);
printf("p2 = %p\n",p2);
printf("p3 = %p\n",p3);
Singleton::destroyInstance();
Singleton::destroyInstance();
Singleton::destroyInstance();
cout << "......end......" << endl;
}
运行结果:
......begin......
Singleton()
p1 = 0x22c8030
p2 = 0x22c8030
p3 = 0x22c8030
~Singleton()
......end......
二、返回引用,饿汉式:
#ifndef __CC_SINGLETON_H__
#define __CC_SINGLETON_H__
#include <iostream>
using std::cout;
using std::endl;
namespace cc
{
class Singleton
{
public:
static Singleton & getInstance();
private:
Singleton(){cout << "Singleton()" << endl;}
~Singleton(){cout << "~Singleton()" << endl;}
Singleton(const Singleton &) = delete;
Singleton & operator=(const Singleton &) = delete;
private:
static Singleton m_Instance;
};
Singleton Singleton::m_Instance;
Singleton & Singleton::getInstance(){
return m_Instance;
}
}//end of namespace
#endif
三、返回引用,饱汉式:
返回的是静态局部变量,由于静态局部变量是非线程安全的,所以加锁和标志位
#ifndef __CC_SINGLETON_H__
#define __CC_SINGLETON_H__
#include <iostream>
#include <mutex>
using std::cout;
using std::endl;
namespace cc
{
class Singleton
{
public:
static Singleton & getInstance();
private:
static Singleton & createInstance();
private:
Singleton(){cout << "Singleton()" << endl;}
~Singleton(){cout << "~Singleton()" << endl;}
Singleton(const Singleton &) = delete;
Singleton & operator=(const Singleton &) = delete;
private:
//由于局部静态变量是非线程安全的,所以要加锁,并加一个标志位
static bool m_isExisted;//标记实例是否存在
static std::mutex m_mutex;
};
bool Singleton::m_isExisted = false;
std::mutex Singleton::m_mutex;
Singleton & Singleton::getInstance(){
if(false == m_isExisted){
std::lock_guard<std::mutex> guard(m_mutex);
if(false == m_isExisted){
return createInstance();
}
}
return createInstance();
}
Singleton & Singleton::createInstance(){
static Singleton instance;
return instance;
}
}//end of namespace
#endif
三、模板实现:
singleton.h
#ifndef __CC_SINGLETON_H__
#define __CC_SINGLETON_H__
#include <iostream>
#include <mutex>
using std::cout;
using std::endl;
namespace cc
{
template<typename T>
class Singleton
{
public:
static T * getInstance();
static void destroyInstance();
private:
Singleton(){cout << "Singleton()" << endl;}
~Singleton(){cout << "~Singleton()" << endl;}
Singleton(const Singleton &) = delete;
Singleton & operator=(const Singleton &) = delete;
private:
static std::mutex m_mutex;
static T * m_pInstance;
};
template<typename T>
T* Singleton<T>::m_pInstance = nullptr;
template<typename T>
std::mutex Singleton<T>::m_mutex;
template<typename T>
T* Singleton<T>::getInstance(){
if(nullptr == m_pInstance){
std::lock_guard<std::mutex> guard(m_mutex);
if(nullptr == m_pInstance){
m_pInstance = new T;
}
}
return m_pInstance;
}
template<typename T>
void Singleton<T>::destroyInstance(){
if(m_pInstance != nullptr){
delete m_pInstance;
m_pInstance = nullptr;
}
}
}//end of namespace
#endif
test.cc
#include "singleton.h"
#include "stdio.h"
#include <iostream>
#include <string>
using std::cout;
using std::endl;
using std::string;
using namespace cc;
int main(){
cout << "......begin......" << endl;
int *pint1 = Singleton<int>::getInstance();
int *pint2 = Singleton<int>::getInstance();
int *pint3 = Singleton<int>::getInstance();
float *pfloat1 = Singleton<float>::getInstance();
float *pfloat2 = Singleton<float>::getInstance();
float *pfloat3 = Singleton<float>::getInstance();
string *pstr1 = Singleton<string>::getInstance();
string *pstr2 = Singleton<string>::getInstance();
string *pstr3 = Singleton<string>::getInstance();
printf("pint1 = %p\n",pint1);
printf("pint2 = %p\n",pint2);
printf("pint3 = %p\n",pint3);
printf("pfloat1 = %p\n",pfloat1);
printf("pfloat2 = %p\n",pfloat2);
printf("pfloat3 = %p\n",pfloat3);
printf("pstr1 = %p\n",pstr1);
printf("pstr2 = %p\n",pstr2);
printf("pstr3 = %p\n",pstr3);
Singleton<int>::destroyInstance();
Singleton<int>::destroyInstance();
Singleton<int>::destroyInstance();
Singleton<float>::destroyInstance();
Singleton<float>::destroyInstance();
Singleton<float>::destroyInstance();
Singleton<double>::destroyInstance();
Singleton<double>::destroyInstance();
Singleton<double>::destroyInstance();
Singleton<string>::destroyInstance();
Singleton<string>::destroyInstance();
Singleton<string>::destroyInstance();
cout << "......end......" << endl;
}
运行结果:
......begin......
pint1 = 0x1b81030
pint2 = 0x1b81030
pint3 = 0x1b81030
pfloat1 = 0x1b81050
pfloat2 = 0x1b81050
pfloat3 = 0x1b81050
pstr1 = 0x1b81070
pstr2 = 0x1b81070
pstr3 = 0x1b81070
......end......
四、单例模式自动释放:
#ifndef __CC_SINGLETON_H__
#define __CC_SINGLETON_H__
#include <iostream>
#include <mutex>
using std::cout;
using std::endl;
namespace cc
{
class Singleton
{
//嵌套类,自动释放内存
public:
static Singleton * getInstance();
static void destroyInstance();
private:
Singleton(){cout << "Singleton()" << endl;}
~Singleton(){cout << "~Singleton()" << endl;}
Singleton(const Singleton &) = delete;
Singleton & operator=(const Singleton &) = delete;
private:
class Auto;
static Auto _auto;//自动释放类
static std::mutex _mutex;
static Singleton * _pInstance;
};
class Singleton::Auto{
public:
~Auto(){ destroyInstance(); }
};
Singleton::Auto Singleton::_auto;
Singleton* Singleton::_pInstance = nullptr;
std::mutex Singleton::_mutex;
Singleton* Singleton::getInstance(){
if(nullptr == _pInstance){
std::lock_guard<std::mutex> guard(_mutex);
if(nullptr == _pInstance){
_pInstance = new Singleton();
}
}
return _pInstance;
}
void Singleton::destroyInstance(){
if(_pInstance != nullptr){
delete _pInstance;
_pInstance = nullptr;
}
}
}//end of namespace
#endif