目录
多线程下懒汉式单例的Double-Checked Locking优化
单例模式
概念
- 单例模式是一种对象创建型模式,使用单例模式,可以保证为一个类只生成唯一的实例对象。也就是说,在整个程序空间中,该类只存在一个实例对象。
- GoF对单例模式的定义是:保证一个类、只有一个实例存在,同时提供能对该实例加以访问的全局访问方法。
为什么使用单例模式
- 在应用系统开发中,我们常常有以下需求:
- 在多个线程之间,比如初始化一次socket资源;比如servlet环境,共享同一个资源或者操作同一个对象
- 在整个程序空间使用全局变量,共享资源
- 大规模系统中,为了性能的考虑,需要节省对象的创建时间等等。
- 因为Singleton模式可以保证为一个类只生成唯一的实例对象,所以这些情况,Singleton模式就派上用场了。
实现单例步骤常用步骤
- 构造函数私有化
- 提供一个全局的静态方法(全局访问点)
- 在类中定义一个静态指针,指向本类的变量的静态变量指针
懒汉式单例
#include <iostream>
using namespace std;
//懒汉式
class Singelton
{
private:
Singelton()
{
m_singer = NULL;
m_count = 0;
cout << "构造函数Singelton ... do" << endl;
}
public:
static Singelton *getInstance()
{
if (m_singer == NULL ) //懒汉式:1 每次获取实例都要判断 2 多线程会有问题
{
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;
void main01_1()
{
cout << "演示 懒汉式" << endl;
Singelton *p1 = Singelton::getInstance(); //只有在使用的时候,才去创建对象。
Singelton *p2 = Singelton::getInstance();
if (p1 != p2)
{
cout << "不是同一个对象" << endl;
}
else
{
cout << "是同一个对象" << endl;
}
p1->printT();
p2->printT();
system("pause");
return ;
}
饿汉式单例
class Singelton2
{
private:
Singelton2()
{
m_singer = NULL;
m_count = 0;
cout << "构造函数Singelton ... do" << endl;
}
public:
static Singelton2 *getInstance()
{
return m_singer;
}
static void Singelton2::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;
void main()
{
cout << "演示 饿汉式" << endl;
Singelton2 *p1 = Singelton2::getInstance(); //只有在使用的时候,才去创建对象。
Singelton2 *p2 = Singelton2::getInstance();
if (p1 != p2)
{
cout << "不是同一个对象" << endl;
}
else
{
cout << "是同一个对象" << endl;
}
p1->printT();
p2->printT();
Singelton2::FreeInstance();
Singelton2::FreeInstance();
system("pause");
}
多线程下的懒汉式单例和饿汉式单例
- "懒汉"模式虽然有优点,但是每次调用GetInstance()静态方法时,必须判断
- NULL == m_instance,使程序相对开销增大。
- 多线程中会导致多个实例的产生,从而导致运行代码不正确以及内存的泄露。
- 提供释放资源的函数
- 讨论: 这是因为C++中构造函数并不是线程安全的。
- C++中的构造函数简单来说分两步:
- 第一步:内存分配
- 第二步:初始化成员变量
- 由于多线程的关系,可能当我们在分配内存好了以后,还没来得急初始化成员变量,就进行线程切换,另外一个线程拿到所有权后,由于内存已经分配了,但是变量初始化还 没进行,因此打印成员变量的相关值会发生不一致现象。
#include "stdafx.h"
#include "windows.h"
#include "winbase.h"
#include <process.h>
#include "iostream"
using namespace std;
class Singelton
{
private:
Singelton()
{
count ++;
cout<<"Singelton构造函数begin\n"<<endl;
Sleep(1000);
cout<<"Singelton构造函数end\n"<<endl;
}
private:
//防止拷贝构造和赋值操作
Singelton(const Singelton &obj);
Singelton& operator=(const Singelton &obj);
public:
static Singelton *getSingelton()
{
//1"懒汉"模式虽然有优点,但是每次调用GetInstance()静态方法时,必须判断
// NULL == m_instance,使程序相对开销增大。
//2多线程中会导致多个实例的产生,从而导致运行代码不正确以及内存的泄露。
//3提供释放资源的函数
return single;
}
static Singelton *releaseSingelton()
{
if (single != NULL) //需要判断
{
cout<<"释放资源\n"<<endl;
delete single;
single = NULL;
}
return single;
}
void pirntS() //测试函数
{
printf("Singelton printS test count:%d \n", count);
}
private:
static Singelton *single;
static int count;
};
//note 静态变量类外初始化
Singelton *Singelton::single = new Singelton();
int Singelton::count = 0;
int _tmainTTT(int argc, _TCHAR* argv[])
{
Singelton *s1 = Singelton::getSingelton();
Singelton *s2 = Singelton::getSingelton();
if (s1 == s2)
{
cout<<"ok....equal"<<endl;
}
else
{
cout<<"not.equal"<<endl;
}
s1->pirntS();
Singelton::releaseSingelton();
cout <<"hello...."<<endl;
system("pause");
return 0;
}
unsigned int threadfunc2(void *myIpAdd)
{
int id = GetCurrentThreadId();
printf("\n threadfunc%d \n", id);
return 1;
}
void threadfunc(void *myIpAdd)
{
int id = GetCurrentThreadId();
printf("\n threadfunc%d \n", id);
Singelton::getSingelton()->pirntS();
return ;
}
int _tmain(int argc, _TCHAR* argv[])
{
int i = 0;
DWORD dwThreadId[201], dwThrdParam = 1;
HANDLE hThread[201];
int threadnum = 3;
for (i=0; i<threadnum; i++)
{
//hThread[i] = (HANDLE)_beginthreadex( NULL, 0, &threadfunc, NULL, 0,&dwThreadId[i] );
hThread[i] = (HANDLE)_beginthread(&threadfunc, 0 , 0 );
if (hThread[i] == NULL)
{
printf("begin thread %d error!!!\n", i);
break;
}
}
//等待所有的子线程都运行完毕后,才执行 这个代码
for (i=0; i<threadnum; i++)
{
WaitForSingleObject( hThread[i], INFINITE );
}
printf("等待线程结束\n");
for (i=0; i<threadnum; i++)
{
//CloseHandle( hThread[i] );
}
Singelton::releaseSingelton();
cout <<"hello...."<<endl;
system("pause");
return 0;
}
多线程下懒汉式单例的Double-Checked Locking优化
- 新建MFC对话框应用程序。方便使用临界区类对象,同步线程
// MFC Diagram 应用程序
#include "stdafx.h"
#include "01单例优化.h"
#include "01单例优化Dlg.h"
#include "afxdialogex.h"
#include "iostream"
using namespace std;
//临界区
static CCriticalSection cs;
//man pthread_create()
class Singleton
{
private:
Singleton()
{
TRACE("Singleton begin\n");
Sleep(1000);
TRACE("Singleton end\n");
}
Singleton(const Singleton &);
Singleton& operator = (const Singleton &);
public:
static void printV()
{
TRACE("printV..\n");
}
//请思考;懒汉式的Double-Check是一个经典问题!为什么需要2次检查 “if(pInstance == NULL)”
场景:假设有线程1、线程2、线程3,同时资源竞争。
//1)第1个、2个、3个线程执行第一个检查,都有可能进入黄色区域(临界区)
//2)若第1个线程进入到临界区,第2个、第3个线程需要等待
//3)第1个线程执行完毕,cs.unlock()后,第2个、第3个线程要竞争执行临界区代码。
//4)假若第2个线程进入临界区,此时第2个线程需要再次判断 if(pInstance == NULL)”,若第一个线程已经创建实例;第2个线程就不需要再次创建了。保证了单例;
//5)同样道理,若第2个线程,cs.unlock()后,第3个线程会竞争执行临界区代码;此时第3个线程需要再次判断 if(pInstance == NULL)。通过检查发现实例已经new出来,就不需要再次创建;保证了单例。
static Singleton *Instantialize()
{
if(pInstance == NULL) //double check
{
cs.Lock(); //只有当pInstance等于null时,才开始使用加锁机制 二次检查
if(pInstance == NULL)
{
pInstance = new Singleton();
}
cs.Unlock();
}
return pInstance;
}
static Singleton *pInstance;
};
Singleton* Singleton::pInstance = 0;
void CMy01单例优化Dlg::OnBnClickedButton1()
{
CCriticalSection cs;
cs.Lock();
cs.Unlock();
// TODO: 在此添加控件通知处理程序代码
}
void threadfunc(void *myIpAdd)
{
int id = GetCurrentThreadId();
TRACE("\n threadfunc%d \n", id);
Singleton::Instantialize()->printV();
//Singelton::getSingelton()->pirntS();
}
void CMy01单例优化Dlg::OnBnClickedButton2()
{
int i = 0;
DWORD dwThreadId[201], dwThrdParam = 1;
HANDLE hThread[201];
int threadnum = 3;
for (i=0; i<threadnum; i++)
{
//hThread[i] = (HANDLE)_beginthreadex( NULL, 0, &threadfunc, NULL, 0,&dwThreadId[i] );
hThread[i] = (HANDLE)_beginthread(&threadfunc, 0 , 0 );
if (hThread[i] == NULL)
{
TRACE("begin thread %d error!!!\n", i);
break;
}
}
for (i=0; i<threadnum; i++)
{
WaitForSingleObject( hThread[i], INFINITE );
}
TRACE("等待线程结束\n");
for (i=0; i<threadnum; i++)
{
//CloseHandle( hThread[i] );
}
//Singelton::releaseSingelton();
TRACE("ddddd\n");
}
【注】参考传智扫地僧C++设计模式