1. 单例模式
从字面意思就可以看出来单例模式是一个类只能创建一个实例对象,这种创建对象的方法带来的好处就是多线程开发中,初始化一次套接字,共享同一个资源,节省创建对象的时间,有些场景模式下,要求一个类只生成一个唯一的对象。单例模式又分为饿汉式和懒汉式单例模式。
它的基本实现步骤是
(1)先把构造函数私有化
(2)提供一个全局的静态方法(创建对象用)
(3)在类中定义一个静态指针,指向本类的变量的静态变量指针(访问静态方法)
1.2懒汉式单例模式
#include <iostream>
using namespace std;
//懒汉式
class Singelton
{
private:
Singelton()//第一步:构造函数私有化
{
m_singer = NULL;
m_count = 0;
cout << "第一步:构造函数私有化\n" << endl;
}
public:
static Singelton *getInstance()//第二步:提供一个全局的静态方法
{
if (m_singer == NULL ) //懒汉式:1 每次获取实例都要判断
{
m_singer = new Singelton;
}
return m_singer;
}
static void printT()
{
cout << "m_count: " << m_count << endl;
}
private:
static Singelton *m_singer;//第三步:在类中定义一个静态指针,指向本类的变量的静态变量指针
static int m_count;
};
Singelton *Singelton::m_singer = NULL; //懒汉式 并没有创建单例对象
int Singelton::m_count = 0;
int main()
{
Singelton *p1 = Singelton::getInstance(); //只有在使用的时候,才去创建对象。
Singelton *p2 = Singelton::getInstance();
if (p1 != p2)
{
cout << "different object" << endl;
}
else
{
cout << "same object" << endl;
}
p1->printT();
p2->printT();
return 0 ;
}
1.1饿汉式单例模式
#include <iostream>
using namespace std;
class Singelton2
{
private:
Singelton2()//第一步:构造函数私有化
{
m_singer = NULL;
m_count = 0;
cout << "构造函数私有化" << endl;
}
public:
static Singelton2 *getInstance()//第二步:提供全局的静态方法
{
return m_singer;
}
static void FreeInstance()
{
if (m_singer != NULL)
{
delete m_singer;
m_singer = NULL;
m_count = 0;
}
}
static void printT()
{
cout << "m_count: " << m_count << endl;
}
private:
static Singelton2 *m_singer;//第三步:定义静态指针
static int m_count;
};
Singelton2 *Singelton2::m_singer = new Singelton2; //不管你创建不创建实例,均把实例new出来
int Singelton2::m_count = 0;
int main()
{
Singelton2 *p1 = Singelton2::getInstance(); //只有在使用的时候,才去创建对象。
Singelton2 *p2 = Singelton2::getInstance();
if (p1 != p2)
{
cout << "different obj" << endl;
}
else
{
cout << "same obj" << endl;
}
p1->printT();
p2->printT();
Singelton2::FreeInstance();
Singelton2::FreeInstance();
return 0;
}
2总结
多线程中会导致多个实例的产生,从而导致运行代码不正确以及内存的泄露。每次需要创建临界区,访问临界区需要加锁和解锁。