单例模式
参考https://blog.csdn.net/sinat_31135199/article/details/76635052
http://www.runoob.com/design-pattern/singleton-pattern.html
单例模式(Singleton Pattern)提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
意图:保证一个类仅有一个实例,并提供一个访问它的全局访问点。
主要解决:一个全局使用的类频繁地创建与销毁。
何时使用:当您想控制实例数目,节省系统资源的时候。
如何解决:判断系统是否已经有这个单例,如果有则返回,如果没有则创建。
关键代码:构造函数是私有的。
应用实例:
- Windows 是多进程多线程的,在操作一个文件的时候,就不可避免地出现多个进程或线程同时操作一个文件的对象,所以所有文件的处理必须通过唯一的实例来进行
- 一些设备管理器常常设计为单例模式,比如一个电脑有两台打印机,在输出的时候就要处理不能两台打印机打印同一个文件。
优点:
- 在内存里只有一个实例,减少了内存的开销,尤其是频繁的创建和销毁实例
- 避免对资源的多重占用,如写文件操作
缺点:
没有接口,不能继承,与单一职责原则冲突,一个类应该只关心内部逻辑,而不关心外面怎么样来实例化。
使用场景:
- 要求产生唯一序列号
- WEB 中的计数器,不用每次刷新都在数据库里加一次,用单例先缓存起来
- 创建的一个对象需要消耗的资源过多,比如 I/O 与数据库的连接等
注意事项:getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。
实现
我们将创建一个 SingleObject 类。SingleObject 类有它的私有构造函数和本身的一个静态实例。SingleObject 类提供了一个静态方法,供外界获取它的静态实例。
JAVA的几种实现见http://www.runoob.com/design-pattern/singleton-pattern.html
其中包括lazy loading分析,多线程安全分析,C++实现也可参考。以下实现一种**双检锁/双重校验锁(DCL,即double-checked locking)**形式
#include <iostream>
#include <mutex>
#include <thread>
using namespace std;
// 用互斥量构建枷锁类,之所以构建此类是因为如果在Singleton类中建立static的mutex成员,
// 无法在类外初始化,如果不加static又不能保证仅有一个对象,因此专门做一个类
class Lock{
private:
mutex mtx;
public:
void lock(){ mtx.lock(); }
void unlock(){ mtx.unlock(); }
};
class Singleton{
private:
Singleton(int thread_id);
// 为什么要声明拷贝构造函数和operator=?这里应该不允许拷贝和赋值,赋值还能return *this ?
Singleton(const Singleton &);
Singleton & operator = (const Singleton &);
int value;
public:
// static mutex mtx; // getInstance要用,因此声明为静态
// lock和Instance必须放在public中的原因:static数据成员需要在类外进行初始化
static Lock* lock;
static Singleton* Instance;
// 静态成员函数,没有this指针,不能访问对象的非静态数据成员
static Singleton* getInstance(int thread_id);
int getValue();
~Singleton(); // 析构函数不写不行么?
};
Singleton::Singleton(int thread_id): value(thread_id){}
Singleton::Singleton(const Singleton &){}
Singleton& Singleton::operator = (const Singleton &){
return *this;
}
Singleton::~Singleton(){}
Singleton* Singleton::Instance = NULL; // 涉及静态成员的用法,静态数据成员只能在类外初始化,因此只能为public成员
Lock* Singleton::lock = new Lock();
Singleton* Singleton::getInstance(int thread_id){
if(Instance == NULL){
// mtx.lock();
lock->lock();
if(Instance == NULL)
Instance = new Singleton(thread_id);
// mtx.unlock();
lock->unlock();
}
return Instance;
}
int Singleton::getValue(){
return value;
}
mutex iomtx;
void print_thread_id(int thread_id){
Singleton* instance = Singleton::getInstance(thread_id);
iomtx.lock();
cout << "thread_id: " << thread_id << endl;
cout << "Instance is created in thread: " << instance->getValue() << endl;
iomtx.unlock();
}
int main(){
thread threads[2];
for(int i = 0; i < 2; i++){
threads[i] = thread(print_thread_id, i);
}
for(auto & th : threads) th.join();
return 0;
}
单例模式唯一实例为什么必须为静态:
单例模式实现过程如下:
首先,将该类的构造函数私有化(目的是禁止其他程序创建该类的对象);
其次,在本类中自定义一个对象(既然禁止其他程序创建该类的对象,就要自己创建一个供程序使用,否则类就没法用,更不是单例);
最后,提供一个可访问类自定义对象的类成员方法(对外提供该对象的访问方式)。
直白的讲就是,你不能用该类在其他地方创建对象,而是通过该类自身提供的方法访问类中的那个自定义对象。
那么问题的关键来了,程序调用类中方法只有两种方式,
①创建类的一个对象,用该对象去调用类中方法;
②使用类名直接调用类中方法,格式“类名::方法名()”;
上面说了,构造函数私有化后第一种情况就不能用,只能使用第二种方法。
而使用类名直接调用类中的方法,类中方法必须是静态static的,而静态方法不能访问非静态成员变量,因此类自定义的实例变量也必须是静态的
这就是单例模式唯一实例必须设置为静态的原因。