#include
#include
#include
using namespace std;
//基本懒汉模式，用的时候加载，多线程下会有线程安全问题。（不保证单例的确定性）
class CSingleton_hungry
{
public:
static CSingleton_hungry* GetInstance()
{
if (m_pInstance == NULL)
m_pInstance = new CSingleton_hungry();
return m_pInstance;
}
private:
CSingleton_hungry() {
count++;
std::cout << "默认初始化hungry"<< count << char(10);
};
static CSingleton_hungry* m_pInstance;
static int count;
};
//在外面初始化的时候 这个静态函数会先调用类的构造
//懒汉变饿汉最简单的就是把CSingleton_hungry*的 *号去掉。
CSingleton_hungry* CSingleton_hungry::m_pInstance = NULL;
int CSingleton_hungry::count = 0;
//-------------------------我是大帅比------------------------------------------------------------------
//听说这是C++标准提高以后的方式 局部静态变量可以保证线程安全。下面是老版本的写法个人理解，就是把本来声明一个类的指针，直接声明称类的实例就可以了。
class CSingleton_lazybaby
{
private:
CSingleton_lazybaby()
{
std::cout << "默认初始化lazyrn" << char(10);
}
public:
static CSingleton_lazybaby* GetInstance()
{
static CSingleton_lazybaby instance;
return &instance;
}
};
//旧版标准
//C98标准 不理解
class CMsBsGPSInfoStart
{
public:
static CMsBsGPSInfoStart& GetInstance();
protected:
CMsBsGPSInfoStart();
~CMsBsGPSInfoStart();
private:
static CMsBsGPSInfoStart _instance;
private:
//CLock m_lkMsBsGPSInfoStartFlag;
bool m_bMsBsGPSInfoStartFlag; //
public:
bool GetMsBsGPSInfoStart();
bool SetMsBsGPSInfoStart(bool bIsStart);
};
CMsBsGPSInfoStart CMsBsGPSInfoStart::_instance;
CMsBsGPSInfoStart::CMsBsGPSInfoStart() : m_bMsBsGPSInfoStartFlag(false)
{
std::cout << "enter CMsBsGPSInfoStart::CMsBsGPSInfoStart() " << endl;
}
CMsBsGPSInfoStart::~CMsBsGPSInfoStart()
{
std::cout << "enter CMsBsGPSInfoStart::~CMsBsGPSInfoStart() " << endl;
}
CMsBsGPSInfoStart& CMsBsGPSInfoStart::GetInstance()
{
std::cout << "CMsBsGPSInfoStart::GetInstance()" << endl;
return _instance;
}
bool CMsBsGPSInfoStart::SetMsBsGPSInfoStart(bool bIsStart)
{
m_bMsBsGPSInfoStartFlag = bIsStart;
return true;
}
//--------------------------------------我是大帅比-------------------------------------------------
//这个应该是变种的饿汉模式，类里面嵌套类，目的是析构的时候可以把单例给析构掉。直接在主类里面声明嵌套类的static常量，然后类外初始化，为了实现这个实例，主类先实现，再实现嵌套类，嵌套类初始化就把单例给获取了。main前实现，线程安全。
class Single1
{
public:
static Single1* Getinstance()
{
if (instance == nullptr)
{
instance = new Single1();
}
return instance;
}
private:
Single1() {
std::cout << "single1 构造" << char(10);
}
static Single1* instance;
class helpDele
{
public:
helpDele()
{
Single1::Getinstance();
}
~helpDele()
{
if (instance != NULL)
{
delete instance;
std::cout << "instace被析构" << char(10);
}
}
};
static helpDele helpdele;
};
Single1* Single1::instance = NULL;
Single1::helpDele Single1::helpdele;
void TestSing(int i)
{
Sleep(10);
//CSingleton_lazybaby* lazy = CSingleton_lazybaby::GetInstance();
//printf("线程%d号，lazy====%0xrn", i, lazy);
//CSingleton_hungry* hungy = CSingleton_hungry::GetInstance();
//printf("线程%d号，hungy====%0xrn", i, hungy);
Single1* single1 = Single1::Getinstance();
printf("线程%d号，hungy====%0xrn", i, single1);
_endthread();
}
//--------------------------------------我是大帅比------------------------------------------------
//写在最后，大家可以拿去跑一下，除了最后一个，前面的代码都是网上抄的权侵删。谢谢
//如果你真的跑了，可以把析构函数加上，看看有没有析构和析构的顺序，以及最后为什么会写个辅助类来析构
//还有很多加lock的 ，本人对lock不太熟，类写习惯了越方便越好，不过以后多线程编程肯定是要锁的大家可以研究下。谢谢观看
int main() {
for (int i = 0; i < 20; i++)
{
_beginthreadex(NULL, NULL, (_beginthreadex_proc_type)&TestSing, (void*)i, 0, NULL);
}
system("pausern");
}
