一、什么是单例模式?
单例模式是类的设计模式,使用这个模式设计出来的类运行期间最多只有一个实例,为什么是最多呢,因为它有可能整个运行完了都没有创建。
既然单例模式这么常见,那么它有什么优点呢?节省内存(仅有一个对象)加快访问速度(不用频繁创建),缺点在于没有接口,不能继承。
二、单例模式适用场景
- 唯一序列号
- WEB计数器
- 创建耗时对象(IO及数据库连接)
要想了解更多,可以看看这个:https://blog.csdn.net/tanyujing/article/details/14160941
三、单例模式的分类
单例模式分为两类:
- 预加载型
- 用到再加载型
前者被称为饿汉模式,后者被称为懒汉模式。前者未雨绸缪是一个曾经过过吃不饱穿不暖的日子,所以他总是先创建好,需要时随时都可以拿到,未雨绸缪;后者是一个小康家庭,从来没有过过苦日子,所以他总是用的时候再去创建。个人觉得这两种人呢,都是好人,关键是你对资源的及时性有没有要求。
四、具体实现
无论是衣食无忧型的懒汉还是未雨绸缪型的饿汉,首先要满足的条件就是让用户没法构造,在C++里最简单的方法就是让构造函数私有化。
4.1 未雨绸缪型实现
class Singleton
{
private:
Singleton(){std::cout<<"Created an singleton"<<endl;}
static Singleton * pinstance;
public:
static Singleton * GetInstance(){return pinstance;}
};
Singleton * Singleton::pinstance = new Singleton;//静态成员在main函数之前都创建好了,未雨绸缪啊!!!
其实构造函数可以直接声明为delete,为了观察单例是否是多次调用仅产生一次,所以才使用其等价实现——私有化构造函数。
整个单例类包含:
- 一个已经delete的构造函数;
- 一个指new对象的静态指针;
- 一个返回静态指针的静态方法;
注意:静态成员在主函数执行之前保证已经初始化。上面这种方法是线程安全的。
4.2 衣食无忧型实现
因为该方式是在用户主动调用GetInstance()时才开始创建,所以对象创建放在静态成员函数GetInstance中。
class Singleton
{
public:
static Singleton * p_instance;
static Singleton * GetInstance();
private:
Singleton(){cout<<"Contructor running"<<endl;}
};
Singleton * Singleton::p_instance=nullptr;
Singleton * Singleton::GetInstance()
{
p_instance=new Singleton();
return p_instance;
}
要实现多次调用GetInstance()返回相同的对象,上面获得的对象等于调用次数,不符合要求。解决方法很简单,如果指向对象的指针为nullptr那么就不进入new语句,实现如下:
class Singleton
{
public:
static Singleton * p_instance;
static Singleton * GetInstance();
private:
Singleton(){cout<<"Contructor running"<<endl;}
};
Singleton * Singleton::p_instance=NULL;
Singleton * Singleton::GetInstance()
{
if(p_instance==NULL)
p_instance=new Singleton();
return p_instance;
}
在多线程环境下进行测试:
int main()
{
pthread_t * th;
vector<pthread_t *> vec_pth;
for(int i=0;i<100;i++)
{
th=new pthread_t;
vec_pth.push_back(th);
pthread_create(vec_pth[i],NULL,fun,NULL);
}
for(int i=0;i<100;i++)
{
pthread_join(*vec_pth[i],NULL);
}
}
void * fun(void *)
{
Singleton::GetInstance();
}
不同线程可能同时调用GetInstance(),计算机还没有来得及更新p_instance就已经进入new语句,导致创建了多个对象,运行结果非常不稳定,在我的系统里创建3-5次对象。这是不符合单例的要求的。可以借助线程锁保证每次仅有一个线程进判断,从而保证单例已经顺利创建,其他来的晚的进程就只能返回首个进程创建的对象了。
class Singleton
{
public:
static Singleton * p_instance;
static Singleton * GetInstance();
pthread_mutex_t lo;
private:
Singleton(){cout<<"Contructor running"<<endl;}
static pthread_mutex_t lo;
};
Singleton * Singleton::p_instance=nullptr;
Singleton::pthread_mutex_init(&lo);
Singleton * Singleton::GetInstance()
{
pthread_mutex_lock(&lo);
if(p_instance==nullptr)
p_instance=new Singleton();
pthread_mutex_unlock(&lo);
return p_instance;
}
线程加锁和解锁需要时间,为了解决这个问题,在2004年Scott Meyers and Andrei Alexandrescu在名字为<C++ and the Perils of Double-Checked Locking >
中提出double-check机制减少加锁和解锁的次数,最终的代码如下:
class Singleton
{
public:
static Singleton * p_instance;
static Singleton * GetInstance();
Singleton(){cout<<"Contructor running"<<endl;}
private:
};
Singleton * Singleton::p_instance=NULL;
Singleton * Singleton::GetInstance()
{
if(p_instance==nullptr)
{
pthread_mutex_lock(&lo);
if(p_instance==nullptr)
p_instance=new Singleton();
pthread_mutex_unlock(&lo);
}
pthread_mutex_unlock(&lo);
return p_instance;
}
无论是懒汉还是饿汉都没有考虑拷贝构造、赋值。其实最佳的实现应该是以下方法:
五、C++11标准下实现方法
方法一: 使用返回局部静态变量,这种方法
#include <iostream>
#include <stdlib.h>
#include <vector>
#include <unistd.h>
#include <pthread.h>
using namespace std;
class Singleton
{
public:
static Singleton & GetInstance2();
private:
Singleton(){cout<<"Contructor running"<<endl;}
};
Singleton & Singleton::GetInstance2()
{
static Singleton instance=Singleton();
return instance;
}
void * fun(void *)
{
Singleton::GetInstance2();
}
int main()
{
pthread_t * th;
vector<pthread_t *> vec_pth;
for(int i=0;i<100;i++)
{
th=new pthread_t;
vec_pth.push_back(th);
pthread_create(vec_pth[i],NULL,fun,NULL);
}
for(int i=0;i<100;i++)
{
pthread_join(*vec_pth[i],NULL);
}
}
方法二:callonce
class Singleton {
public:
static Singleton* getInstance() {
static std::once_flag onceFlag; // 必须是静态的
std::call_once(onceFlag, [&] {m_instance = new Singleton(); }); // 只会调用一次
return m_instance;
}
private:
Singleton() {} //私有构造函数,不允许使用者自己生成对象,但是必须要实现
Singleton(const Singleton& other) = delete;
Singleton& operator = (const Singleton& other) = delete;
private:
static Singleton* m_instance; //静态成员变量
};
Singleton* Singleton::m_instance = nullptr; //静态成员需要先初始化
https://en.cppreference.com/w/cpp/thread/call_once
[1]https://zh.wikipedia.org/wiki/%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%BC%8F
[2]https://www.cnblogs.com/restartyang/articles/7770856.html
[3]https://blog.csdn.net/qq_36186690/article/details/82945836
[4]https://stackoverflow.com/questions/2576022/efficient-thread-safe-singleton-in-c