游戏设计模式——C++单例类

前言：

本文将探讨单例类设计模式，单例类的懒汉模式/饿汉模式，单例类的多线程安全性，最后将利用C++模板减少单例类代码量。

本文假设有一个Manager管理类，并以此为探究单例类的设计模式。

懒汉模式

懒汉模式：顾名思义，是一种典型的拖延（lazy）策略。当第一次要用单例类的时候，再产生实例。

类声明：

class Manager{
public:
~Manager();
//提供单例对象访问
static Manager* getInstance();
//删除单例对象
static void deleteInstance();
void dosomething();protected:
//构造函数声明为 保护方法
Manager();
//单例对象指针
static Manager* s_Manager;
};

//单例对象指针初始化为nullptr，防止指向了未定义的数据
Manager* Manager::s_Manager = nullptr;//提供单例类对象访问
Manager* Manager::getInstance(){
   //当没有存在实例时（一般是指准备第一次用）时，才生成新实例
   if(!s_Manager)s_Manager = new CacheManger();
   return s_Manager;
}//删除单例类
void Manager::deleteInstance(){
   if(s_Manager){deleted s_Manager;s_Manager = nullptr;//别忘了赋予空指针，否则指向未定义数据
   }
}void Manager::dosomething(){
   //dosometing
}

这样我们就能在平时的程序用

Manager::getInstance()->dosomething();

来运用单例类来做某些操作了。

懒汉模式with线程安全

但是上面的例子，并不能保证线程安全。

假如没有实例时，然后某两个线程都几乎同时使用getInstance()，那么很可能会产生2份实例，其中一份还会变成泄露的内存。

为了解决线程安全问题，自然想到用锁：（本文使用了C++11 <mutex>的std::mutex作为互斥锁，在类额外增加了一个静态变量std::mutext s_mtx;）

//提供单例类对象访问
Manager* Manager::getInstance() {if (!s_Manager) {//上锁std::lock_guard<std::mutex> lock(s_mtx);//当没有存在实例时（一般是指准备第一次用）时，才生成新实例if (!s_Manager){s_Manager = new Manager();}//解锁
    }return s_Manager;
}//删除单例类
void Manager::deleteInstance() {if (s_Manager) {//上锁std::lock_guard<std::mutex> lock(s_mtx);if (s_Manager) {delete s_Manager;//别忘了赋予空指针，否则指向未定义的数据s_Manager = nullptr;}//解锁
    }
}

为什么不是（上锁，检查，操作，解锁）或者（检查，上锁，操作，解锁），而是使用了双重检查（检查，上锁，检查，操作，解锁）？

上锁的成本远远比检查空指针要高，且当需要产生实例时才需要锁操作。而实际上大量多次使用getInstance时（因为已经产生了实例）并不需要上锁，若先上锁，则会严重造成性能阻塞。
仅仅是检查后再上锁，则根本没有做到任何线程安全。

饿汉模式

饿汉模式与懒汉模式相反，是程序一开始就生成唯一实例。这样就不用检查是否存在实例，而且也无需考虑产生实例时的线程安全。

class Manager {
public:~Manager();//提供单例对象访问static Manager& getInstance();void dosomething();
protected://构造函数声明为 保护方法
    Manager();//单例对象指针static Manager s_Manager;
};//提供单例类对象访问
Manager& Manager::getInstance(){return s_Manager;
}

使用方法：

Manager::getInstance().dosomething();

可以看到代码比懒汉模式简单多了。

在大量使用检查空指针造成的性能瓶颈而内存始终充足时，可以考虑使用饿汉模式

Meyers Singleton(目前最推荐的C++单例写法)

class Singleton {
public:static Singleton& Instance() {static Singleton theSingleton;return theSingleton;}
private:Singleton();Singleton(Singleton const&);Singleton& operator=(Singleton const&); ~Singleton();
};

这段代码很简单，虽然看上去和懒汉模式类似，只是static变量的位置从类移动到了实例获取函数内。

但是实际上由于C++的机制，当第一次调用该函数时，实例才会被构建出来。

这样既可以得到饿汉模式的线程安全，又可以有懒汉模式的按需分配的功能。

应用场景注意

单例类设计模式算是比较经典的一个模式，但是需要注意，它并不是想象中那么美好。

它是一种换皮的全局变量。
它促进了耦合。
它可能对并发不友好（取决于你使用的单例写法）。

一些替代方案：

当你仅需要全局可见的方法时，应该用类静态方法而不是一个类实例。
尽可能为实例提供其它便捷的访问方式（传参/基类获取/服务定位器获取等），而不是通过提供全局可见的访问方式。
如果你只是需要类保证只有唯一对象而不需要全局性，那么应对外封闭获取实例接口（其实就是不可全局获取实例的）。

所以要注意单例类设计模式不应被泛用，通过上面的替代方案多多少少也就减少了很多不必要的单例设计。

游戏设计模式系列-其他文章：

https://www.cnblogs.com/KillerAery/category/1307176.html

转载于:https://www.cnblogs.com/KillerAery/p/9097529.html