singleton单例模式 单件模式
保证一个类中仅有一个实例,并且提供一个访问他的全局访问点
a. 懒汉式:使用的时候才创建,多线程访问的时候线程不安全(双检锁)
b. 饿汉式:类文件加载的时候已经创建好了对象,如果对象一直没有使用,则类对象浪费空间
#注意
1. 构造函数私有化,
2. 私有的静态类指针指向类的实例(类外声明)
3. 共有的静态方法去获取一个访问实例的访问点
4. 析构函数需要定义一个嵌套类的析构函数去释放单例
5. 绝对不要在单例的析构函数中释放单例(coredump)!!!!!!!!! 详情看下面有问题的单例代码
a. 懒汉式:使用的时候才创建,多线程访问的时候线程不安全(双检锁)
b. 饿汉式:类文件加载的时候已经创建好了对象,如果对象一直没有使用,则类对象浪费空间
#注意
1. 构造函数私有化,
2. 私有的静态类指针指向类的实例(类外声明)
3. 共有的静态方法去获取一个访问实例的访问点
4. 析构函数需要定义一个嵌套类的析构函数去释放单例
5. 绝对不要在单例的析构函数中释放单例(coredump)!!!!!!!!! 详情看下面有问题的单例代码
#include <iostream>
using namespace std;
class A
{
private:
static A *m_p;
public:
static A *getSingleTon()
{
if(NULL == m_p)
{
m_p = new A();
}
return m_p;
}
/* ~A()
{
if(NULL != m_p)
{
cout << "xxx" << endl;
delete m_p; // 递归调用析构
m_p = NULL;
cout << "yyy" << endl; // 永远也不会执行
}
}
*/
};
A* A::m_p = NULL;
int main()
{
A *p = A::getSingleTon();
delete p;
return 0;
}
所以 单例析构函数:定义一个静态的嵌套类对象的析构函数去析构单例对象 ,简单思想看如下代码:
#include<iostream>
using namespace std;
//嵌套类去析构单例类对象
class A
{
public:
~A()
{
cout << "deconstructor A" << endl;
}
class B
{
public:
~B() //嵌套类成员的析构函数去析构单例函数的对象
{
cout << "调用嵌套 deconstructor B" << endl;
}
};
private:
static B b;
static int a;
};
int A::a = 10;
A::B A::b; //嵌套静态类成语,必须类外声明
int main()
{
return 0;
}
需要清楚一下几点:
1、单例中的 new 的对象需要delete释放。
2、delete释放对象的时候才会调用对象的析构函数。
3、如果在析构函数里调用delete,那么程序结束时,根本进不去析构函数,怎么会delete。
4、如果程序结束能自动析构,那么就会造成一个析构的循坏,所以new对应于delete。
/
A.懒汉式单例模式
//懒汉式 (创建的时候采取new实例)以时间换取空间,线程不安全
class singleton_L
{
public:
static singleton_L* getinstance()
{
if(instance == NULL)
{
instance = new singleton_L();
}
return instance;
}
//实际上在析构函数中析构对象是一种错误的做法,会调用,切是一个死递归,正确做法是创建一个嵌套的析构类
/*~singleton_L()
{
if(instance != NULL)
{
delete instance;
instance = NULL;
}
cout << "~singleton_L()" << endl;
}*/
private:
class Garbo //设置为私有防止外界访问
{
public:
~Garbo()//实际去析构new的单例对象
{
if(singleton_L::instance != NULL)
{
cout << "delete singleton" << endl;
delete singleton_L::instance;
singleton_L::instance = NULL;
}
}
};
private:
singleton_L(){}
static singleton_L* instance; //单例唯一实力
static Garbo garbo; //静态私有的嵌套类对象,防止被外界访问
};
singleton_L* singleton_L::instance = NULL;
singleton_L::Garbo singleton_L::garbo; //静态类对象类外声
B懒汉式 ,线程安全方法
//懒汉式 线程安全式(双检锁)
/*
所谓双重检查加锁机制,指的是:并不是每次进入getInstance方法都需要同步,而是先不
同步,进入方法过后,先检查实例是否存在,如果不存在才进入下面的同步块,这是第一重
检查。进入同步块过后,再次检查实例是否存在,如果不存在,就在同步的情况下创建一个
实例,这是第二重检查。这样一来,就只需要同步一次了,从而减少了多次在同步情况下进
行判断所浪费的时间。
*/
class singleton_L_Lock
{
public:
static singleton_L_Lock* getinstance()
{
if(instance == NULL)
{
pthread_mutex_lock(&mutex); //加锁
if(instance == NULL)
instance = new singleton_L_Lock();
pthread_mutex_unlock(&mutex);
}
return instance;
}
private:
class GGGarbo
{
public:
~GGGarbo()
{
if(singleton_L_Lock::instance != NULL)
{
delete singleton_L_Lock::instance;
singleton_L_Lock::instance = NULL;
}
}
};
public:
static pthread_mutex_t mutex;
private:
singleton_L_Lock()
{
pthread_mutex_init(&mutex, NULL);
}
private:
static singleton_L_Lock* instance;
static GGGarbo gggarbo;
};
singleton_L_Lock* singleton_L_Lock::instance = NULL;
pthread_mutex_t singleton_L_Lock::mutex;
singleton_L_Lock::GGGarbo singleton_L_Lock::gggarbo;
c.饿汉式
,不牵扯线程安不安全,以空间换时间
//饿汉式(在定义实例的时候就去new对象)以空间换时间
class singleton_E
{
public:
static singleton_E* getinstance()
{
return instance;
}
// ~singleton_E(){}
class GGarbo
{
public:
~GGarbo()
{
if(singleton_E::instance != NULL)
{
cout << "delete singleton_E" << endl;
delete singleton_E::instance;
singleton_E::instance = NULL;
}
}
};
private:
singleton_E(){}
static singleton_E* instance;
static GGarbo ggarbo;
};
singleton_E* singleton_E::instance = new singleton_E();
singleton_E::GGarbo singleton_E::ggarbo;
以上就是我对单例模式的一些理解心得,如有不对的地方多多指教,哈哈哈。