什么是单例设计模式
什么是单例设计模式?
指的是,在一个程序中只能存在一个的对象。即当多次创建时,后面创建的对象都指向第一个创建的对象。
- 将类的构造函数私有化
- 定义一个私有的静态类指针
- 创建一个函数用于判断上面的静态类指针是否为空,为空则新创建一个,不为空则直接返回上面的静态指针
- 创建一个内部类对象,用于释放整个静态指针,防止内存的溢出
#include<iostream>
using namespace std;
/*
创建单例设计模式的方法:
1. 将类的构造函数私有化
2. 定义一个私有的静态类指针
3. 创建一个函数用于判断上面的静态类指针是否为空,为空则新创建一个,不为空则直接返回上面的静态指针
4. 创建一个内部类对象,用于释放整个静态指针,防止内存的溢出
*/
class SignalCase
{
private:
SignalCase() {};
private:
static SignalCase* signalInstance;
public:
static SignalCase* getInstance()
{
if (signalInstance == NULL)
{
signalInstance = new SignalCase();
static inClass cl;
}
return signalInstance;
}
class inClass
{
public:
~inClass()
{
if (signalInstance != NULL)
{
delete SignalCase::signalInstance;
SignalCase::signalInstance = NULL;
}
}
};
};
SignalCase* SignalCase::signalInstance = NULL;
int main()
{
SignalCase* c1 = SignalCase::getInstance();
SignalCase* c2 = SignalCase::getInstance();
cout << c1 << endl;
cout << c2 << endl;
}
c1和c2的地址是一样的,即说明其指向的是同一个对象
单例对象在并发下会发生错误?
static SignalCase* getInstance()
{
if (signalInstance == NULL)
{
signalInstance = new SignalCase();
static inClass cl;
}
return signalInstance;
}
针对于这段代码
- 当线程1执行到if语句中,判断为静态成员变量为空,则会执行if内的语句。如果此时线程切换到线程2
- 线程2判断静态成员变量依然为空,依然会执行if内的语句,这样就会导致一个静态成员变量被赋值两次
会导致错误
解决方法
可以使用互斥量的方式
class SignalCase
{
private:
SignalCase() {};
private:
static SignalCase* signalInstance;
static mutex mut;
public:
static SignalCase* getInstance()
{
unique_lock<mutex> cur1(mut);
if (signalInstance == NULL)
{
signalInstance = new SignalCase();
static inClass cl;
}
return signalInstance;
}
class inClass
{
public:
~inClass()
{
if (signalInstance != NULL)
{
delete SignalCase::signalInstance;
SignalCase::signalInstance = NULL;
}
}
};
};
但是这里会导致时间的浪费,在每一次线程执行到getInstance时都要加锁,然后再判断。如果对于确定静态成员变量为空的线程这就是不必要的时间浪费
如何解决呢?
解决方法
可以使用二重判断的方式,即在外面再添加一个if判断,当确定不为空时不会再有加锁和解锁的操作了
static SignalCase* getInstance()
{
if (signalInstance == NULL) {
unique_lock<mutex> cur1(mut);
if (signalInstance == NULL)
{
signalInstance = new SignalCase();
static inClass cl;
}
}
return signalInstance;
}
call_once()
std::call_once()也可以保证函数只执行一次,用在这里也是可以的
class SignalCase
{
private:
SignalCase() {};
private:
static SignalCase* signalInstance;
static mutex mut;
static once_flag flag;
public:
static void createInstance()
{
signalInstance = new SignalCase();
static inClass c1;
}
static SignalCase* getInstance()
{
call_once(flag, createInstance);
return signalInstance;
}
class inClass
{
public:
~inClass()
{
if (signalInstance != NULL)
{
delete SignalCase::signalInstance;
SignalCase::signalInstance = NULL;
}
}
};
};
这里可能会有疑问
- 如果两个线程都执行到了call_once()这条语句,那不还是会导致flag不能确定吗?
事实并不是这样,call_once再执行时会默认加一个锁,多线程执行到该条语句时要等待其他线程执行完毕之后才能执行,这样创建的once_flag就已经发生改变了,即不会再次执行call_once内定于的函数了