1.单例模式的定义
确保一个类只有一个实例,并且提供一个全局访问点来访问这唯一实例;
特点:
- 一个类只有一个实例
- 必须自己创建这个实例
- 必须向整个系统提供这个实例
2 实例
2.1 创建方式:
- 将构造函数私有化,这样能保证只能在类内进行实例化;
- 实例对象设置为静态;
- 设置获取实例对象函数;
2.2具体实例
#include<iostream>
#include<string>
using namespace std;
class singleton
{
public:
static singleton* getItself()
{
if (!itself)
{
std::cout << "开始创建" << endl;
itself = new singleton();
}
return itself;//获取指针;
}
private:
singleton() {
}//将构造函数私有化;
static singleton*itself;//定义全局变量指针
};
singleton*singleton::itself = NULL;
int main()//测试代码;
{
singleton*s1 = singleton:: getItself();
singleton*s2 = singleton::getItself();
return 0;
}
3多线程下的安全问题
3.1 多线程下创建线程
采用多线程形式创建单例模式:
#include<iostream>
#include<string>
#include <process.h>
#include <Windows.h>
#define THREAD_NUM 5
using namespace std;
class singleton
{
public:
static singleton* getItself()
{
if (!itself)
{
std::cout << "开始创建" << endl;
itself = new singleton();
}
return itself;
}
private:
singleton() {
}
static singleton*itself;
};
singleton*singleton::itself = NULL;
/*非线程安全 单例模式*/
unsigned int __stdcall CallSingleton(void *pPM)
{
singleton *s = singleton::getItself();
int nThreadNum = *(int *)pPM;
Sleep(50);
printf("线程编号为%d\n", nThreadNum);
return 0;
}
int main()
{
HANDLE handle[THREAD_NUM];
//线程编号
int threadNum = 0;
while (threadNum < THREAD_NUM)
{
handle[threadNum] = (HANDLE)_beginthreadex(NULL, 0, CallSingleton, &threadNum, 0, NULL);
//等子线程接收到参数时主线程可能改变了这个i的值
threadNum++;
}
//保证子线程已全部运行结束
WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);
system("pause");
return 0;
}
运行结果:
发现有多个实例被创建,所以其不是线程安全的;
3.2 添加锁;
#include<mutex>
#define THREAD_NUM 5
using namespace std;
class singleton
{
public:
static singleton* getItself()
{
m_lock.lock();
if (!itself)
{
std::cout << "开始创建" << endl;
itself = new singleton();
}
return itself;
m_lock.unlock();
}
private:
static std::mutex m_lock;
singleton() {
}
static singleton*itself;
};
singleton*singleton::itself = NULL;
std::mutex singleton::m_lock;
运行结果:
4懒汉模式和饿汉模式
4.1 懒汉模式
定义:当程序需要创建该单例实例时,才会去进行创建;
参考:懒汉模式
4.2 懒汉模式(加锁模式)
class singleton
{
public:
static singleton* getItself()
{
m_lock.lock();
if (!itself)
{
std::cout << "开始创建" << endl;
itself = new singleton();
}
return itself;
m_lock.unlock();
}
private:
static std::mutex m_lock;
singleton() {
}
static singleton*itself;
};
singleton*singleton::itself = NULL;
std::mutex singleton::m_lock;
4.3 懒汉模式,智能指针+互斥锁
#include <iostream>
#include <memory> // shared_ptr
#include <mutex> // mutex
#include<thread>
using namespace std;
class Singleton {
public:
typedef std::shared_ptr<Singleton> Ptr; //智能指针可以释放聂村
~Singleton() {
cout << "析构函数" << endl;
}
static Ptr getInstance() {
if (_instance == nullptr) { //双检锁
//加锁
std::lock_guard<std::mutex> lk(_mutex);
_instance = std::shared_ptr<Singleton>(new Singleton);
}
return _instance;
}
private:
//构造函数
Singleton();
//复制构造函数 和 赋值构造函数
Singleton(const Singleton &sigle);
const Singleton &operator=(const Singleton &sigle);
static Ptr _instance;
static std::mutex _mutex;
};
Singleton::Ptr Singleton::_instance = nullptr;
std::mutex Singleton::_mutex;
Singleton::Singleton::Singleton() {
cout << "构造函数" << endl;
}
智能指针用于保证其内存安全,互斥锁用于保证其线程安全;
测试代码:
void proc()
{
cout << "我是次线程" << endl;
Singleton::Ptr p = Singleton::getInstance();
cout << "&p1 = " << p << endl;
}
int main() {
cout << "我是主线程" << endl;
thread th2(proc);//第一个参数为函数名,第二个参数为该函数的第一个参数,如果该函数接收多个参数就依次写在后面。此时线程开始执行。
cout << "主线程中显示子线程id为" << th2.get_id() << endl;
thread th3(proc);
cout << "主线程中显示子线程id为" << th3.get_id() << endl;
th3.join();//此时主线程被阻塞直至子线程执行结束。
th2.join();//此时主线程被阻塞直至子线程执行结束。
return 0;
}
运行结果:
4.4 懒汉模式,基于C++11 特性,先定义全局变量
#include <iostream>
#include <memory> // shared_ptr
#include <mutex> // mutex
#include<thread>
using namespace std;
class Singleton {
public:
static Singleton&GetIt()
{
static Singleton itself;
return itself;
}
private:
Singleton() {
std::cout << "构造函数" << std::endl;
}
~Singleton() {
std::cout << "析构函数" << std::endl;
}
//复制构造函数 和 赋值构造函数
Singleton(const Singleton &sigle);
const Singleton &operator=(const Singleton &sigle);
};
void proc()//线程函数
{
cout << "我是次线程" << endl;
Singleton& p = Singleton::GetIt();
cout << &p << endl;
}
int main() {
cout << "我是主线程" << endl;
int a = 9;
thread th2(proc);//第一个参数为函数名,第二个参数为该函数的第一个参数,如果该函数接收多个参数就依次写在后面。此时线程开始执行。
cout << "主线程中显示子线程id为" << th2.get_id() << endl;
thread th3(proc);
cout << "主线程中显示子线程id为" << th3.get_id() << endl;
th3.join();//此时主线程被阻塞直至子线程执行结束。
th2.join();//此时主线程被阻塞直至子线程执行结束。
return 0;
}
原理:如果当变量在初始化的时候,并发同时进入声明语句,并发线程将会阻塞等待初始化结束。
4.5 饿汉模式
进程一开始就被创建,所以不存在线程安全;
#include <iostream>
#include <memory> // shared_ptr
#include <mutex> // mutex
#include<thread>
using namespace std;
class Singleton {
public:
static Singleton*getIt()
{
return instance;
}
private:
Singleton() {
std::cout << "构造函数" << std::endl;
}
~Singleton() {
std::cout << "析构函数" << std::endl;
}
//复制构造函数 和 赋值构造函数
Singleton(const Singleton &sigle);
const Singleton &operator=(const Singleton &sigle);
static Singleton*instance;
};
Singleton*Singleton::instance = new Singleton();
void proc()
{
cout << "我是次线程" << endl;
Singleton*p = Singleton::getIt();
cout << p << endl;
}
int main() {
cout << "我是主线程" << endl;
int a = 9;
thread th2(proc);//第一个参数为函数名,第二个参数为该函数的第一个参数,如果该函数接收多个参数就依次写在后面。此时线程开始执行。
cout << "主线程中显示子线程id为" << th2.get_id() << endl;
thread th3(proc);
cout << "主线程中显示子线程id为" << th3.get_id() << endl;
th3.join();//此时主线程被阻塞直至子线程执行结束。
th2.join();//此时主线程被阻塞直至子线程执行结束。
return 0;
}
注:这里显示构造函数在主线程之前,说明进程一开始就把线程创建了;