//1"懒汉"模式虽然有优点，但是每次调用GetInstance()静态方法时，必须判断
// NULL == m_instance，使程序相对开销增大。
//2多线程中会导致多个实例的产生，从而导致运行代码不正确以及内存的泄露。
//3提供释放资源的函数
讨论: 这是因为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");
}
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");
}
注意：为什么需要2次检查 “if(pInstance == NULL)”？
static Singleton *Instantialize()
{
if(pInstance == NULL) //double check
{
cs.Lock(); //只有当pInstance等于null时，才开始使用加锁机制 二次检查
if(pInstance == NULL)
{
pInstance = new Singleton();
}
cs.Unlock();
}
return pInstance;
}
//请思考；懒汉式的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出来，就不需要再次创建；保证了单例。
程序并发机制扩展阅读
程序的并发执行往往带来与时间有关的错误，甚至引发灾难性的后果。这需要引入同步机制。使用多进程与多线程时，有时需要协同两种或多种动作，此过程就称同步（Synchronization）。引入同步机制的第一个原因是为了控制线程之间的资源同步访问，因为多个线程在共享资源时如果发生访问冲突通常会带来不正确的后果。例如，一个线程正在更新一个结构，同时另一个线程正试图读取同一个结构。结果，我们将无法得知所读取的数据是新的还是旧的，或者是二者的混合。第二个原因是有时要求确保线程之间的动作以指定的次序发生，如一个线程需要等待由另外一个线程所引起的事件。
为了在多线程程序中解决同步问题，Windows提供了四种主要的同步对象，每种对象相对于线程有两种状态——信号状态（signal state）和非信号状态（nonsignalstate）。当相关联的同步对象处于信号状态时，线程可以执行（访问共享资源），反之必须等待。这四种同步对象是：
（1）事件对象（Event）。事件对象作为标志在线程间传递信号。一个或多个线程可等待一个事件对象，当指定的事件发生时，事件对象通知等待线程可以开始执行。它有两种类型：自动重置（auto-reset）事件和手动重置（manual-reset）事件。
（2）临界区（Critical Section）。临界区对象通过提供一个进程内所有线程必须共享的对象来控制线程。只有拥有那个对象的线程可以访问保护资源。在另一个线程可以访问该资源之前，前一个线程必须释放临界区对象，以便新的线程可以索取对象的访问权。
（3）互斥量（Mutex Semaphore）。互斥量的工作方式非常类似于临界区，只是互斥量不仅保护一个进程内为多个线程使用的共享资源，而且还可以保护系统中两个或多个进程之间的的共享资源。
（4）信号量（Semaphore）。信号量可以允许一个或有限个线程访问共享资源。它是通过计数器来实现的，初始化时赋予计数器以可用资源数，当将信号量提供给一个线程时，计数器的值减1，当一个线程释放它时，计数器值加1。当计数器值小于等于0时，相应线程必须等待。信号量是Windows98同步系统的核心。从本质上讲，互斥量是信号量的一种特殊形式。Windows/NT还提供了另外一种Windows95没有的同步对象：可等待定时器（Waitable Timer）。它可以封锁线程的执行，直到到达某一具体时间。这可以用于后台任务。
原文地址：https://www.cnblogs.com/gd-luojialin/p/10357767.html