设计模式 ---单例模式

用户3479834

发布于 2021-02-03 12:32:37

4120

发布于 2021-02-03 12:32:37

文章被收录于专栏：游戏开发司机

单例模式概念

单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。也就是说，在整个程序空间中，该类只存在一个实例对象。
GoF对单例模式的定义是：保证一个类、只有一个实例存在，同时提供能对该实例加以访问的全局访问方法。

一、Singleton意图

保证一个类仅有一个实例，并提供一个访问它的全局访问点

二、动机

在软件系统中，经常有这样一些特殊的类，必须保证它们在系统中只存在一个实例，才能确保它们的逻辑正确性、以及良好的效率
如何绕过常规的构造器，提供一种机制来保证一个类只有一个实例呢？
- 一个错误的办法是：使用一个全局变量使得一个对象可以被访问，但它不能防止你实例化多个对象
- 一个更好的办法是：让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建（通过截取创建新对象的请求），并且它可以提供一个访问该实例的方法。这就是Singleton模式
这应该是类设计者的责任，而不是使用者的责任

三、适用性

在以下情况可以使用Signleton模式：
- 当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时
- 当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时

为什么使用单例模式

在应用系统开发中，我们常常有以下需求：
- 在多个线程之间，比如初始化一次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 main()
{
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 CSingleton
{
private:
       static CSingleton* m_pInstance;

        CSingleton()         //构造函数为private
       {
       }             

       CSingleton& operator = (const CSingleton& t);
       CSingleton(const CSingleton &); 
public:
       static CSingleton* getInstance()
{  
               return m_pInstance;
       }
};

CSingleton* CSingleton::m_pInstance = new CSingleton;

多线程下的懒汉式单例和饿汉式单例

"懒汉"模式虽然有优点，但是每次调用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;
}

最后提供一个模板类：

#include <iostream>
#include <string>
#include "CSingleton.h"

using namespace std;

class Test
{
       friend class CSingleton<Test> ;  //声明Test的友元为单例类模板
private:   
       string mstr;

        Test(): mstr("abc")
       {
       }

       Test& operator = (const Test& t);
       Test(const Test&);

public:    
        void Setmstr(string t)
{
         mstr=t;
　　　　}

        void print()
{
        cout<<"mstr = "<<mstr<<endl;
        cout<<"this = "<<this<<endl;
       }
};

int main()
{
        Test *pt1 = CSingleton<Test>::getInstance();
        Test *pt2 = CSingleton<Test>::getInstance();   

        pt1->print();
        pt2->print();

        pt1->Setmstr("ABCDEFG");
        pt2->print();

        return 0;
}

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2020-12-12，如有侵权请联系 cloudcommunity@tencent.com 删除

编程算法