《游戏编程模式》学习笔记（六）单例模式 Singleton Pattern

单例模式的定义

保证一个类只有一个实例，并且提供了访问该实例的全局访问点。

定义这种东西一般都是不说人话的，要想要理解这句话的意思，我们得把它揉开了才能搞明白。

我们先看前半句 “保证一个类只有一个实例”，单例一般使用类来实现，也就是说，这个单例类，其有且只能有一个实例化的对象instance，一旦出现多个，就不是单例模式。

后半句“并且提供了访问该实例的全局访问点”，这句话的意思是，这个实例化的对象是全局可见的，任何系统，任何类都可以访问这个实例化的单例对象。有这个特性存在是因为单例模式的存在就是为了提供便利的访问，全局可见保证了这种便利性。

如何实现单例

单例的实现方法很简单，最传统的方法如下：

class FileSystem
{
public:
  static FileSystem& instance()
  {
    // 惰性初始化，也就是我们说的“懒汉式”
    if (instance_ == NULL) instance_ = new FileSystem();
    return *instance_;
  }

private:
  FileSystem() {}

  static FileSystem* instance_;
};

这个类的构造函数是私有的，这保证了外部无法实例化这个类的对象。只能通过获取instance()获得实例，保证了单例性。
现在还有一种现代的写法，这种单例的写法可以保证在实例化这个对象的过程是线程安全的，如下：

class FileSystem
{
public:
  static FileSystem& instance()
  {
    static FileSystem *instance = new FileSystem();
    return *instance;
  }

private:
  FileSystem() {}
};

由于本地静态变量只会初始化一次，这保证了其前程安全性。而上一段的代码则不是线程安全的。
注意，单例类本身的线程安全是个不同的问题！这里只保证了它的初始化没问题。

单例的优点是什么？

懒汉式保证了如果没有人使用，就不会创建这个单例
运行时实例化保证了单例可以获取到它需要的所有信息，因为有些信息是只能在运行的时候才能出现。
单例可继承，而使用时候我们只需要基类的单例指针，就可以通过指向不同的子类对象来实现不同的需求。例如，你要做一个跨平台的封装器，我们用单例模式试试：

class FileSystem
{
public:
  static FileSystem& instance();

  virtual ~FileSystem() {}
  virtual char* readFile(char* path) = 0;
  virtual void  writeFile(char* path, char* contents) = 0;

protected:
  FileSystem() {}
};

其子类可以是这样

class PS3FileSystem : public FileSystem
{
public:
  virtual char* readFile(char* path)
  {
    // 使用索尼的文件读写API……
  }

  virtual void writeFile(char* path, char* contents)
  {
    // 使用索尼的文件读写API……
  }
};

class WiiFileSystem : public FileSystem
{
public:
  virtual char* readFile(char* path)
  {
    // 使用任天堂的文件读写API……
  }

  virtual void writeFile(char* path, char* contents)
  {
    // 使用任天堂的文件读写API……
  }
};

获取单例的方法我们就这么写：

FileSystem& FileSystem::instance()
{
  #if PLATFORM == PLAYSTATION3
    static FileSystem *instance = new PS3FileSystem();
  #elif PLATFORM == WII
    static FileSystem *instance = new WiiFileSystem();
  #endif

  return *instance;
}

通过这种方式， 整个代码库都可以使用FileSystem::instance()接触到文件系统，而无需和任何平台相关的代码耦合。

单例的缺点

单例是全局的，大量使用这种全局对象，会让你很难debug。
全局意味着所有的对象都能访问单例，这也促使了耦合的发生。比如你在物理系统里连接了成就系统。
单例模式让线程同步成为了一个大问题。可能会频繁出现死锁，竞争状态，以及其他很难解决的线程同步问题。

懒汉式初始化等于剥夺了你的控制权。如果游戏在运行到关键的时候初始化了一个单例，这游戏不就卡了。

有什么方法可以避免？

每次在使用单例的时候，问问自己是否真的需要它。例如，你的游戏里有一堆的manager，但有些manager是不是删了也行？

有个单例是好事，但是可以不要让它是全局的。例如这样写

class FileSystem
{
public:
  FileSystem()
  {
    assert(!instantiated_);
    instantiated_ = true;
  }

  ~FileSystem() { instantiated_ = false; }

private:
  static bool instantiated_;
};

bool FileSystem::instantiated_ = false;

这段代码和之前单例的代码的不同在于， 任何人都可以构建这个对象，但是只能构建一次。在运行的时候如果别人想要构建这个对象，就会报错。 这段代码保证了没有其他代码可以接触实例或者创建自己的实例。

这个实现的缺点是只在运行时检查并阻止多重实例化。 单例模式正相反，通过类的自然结构，在编译时就能确定实例是单一的。

从别的地方获取单例，而不是从全局。 例如你可以通过传参把你要的东西传进来而不是写单例，你也可以从基类中取得，亦或者你从已经是全局的对象中获取你要的对象。还有一种方法是利用服务定位器模式来提供全局访问，这个模式会在后续的章节中揭露。

原文链接：https://gpp.tkchu.me/singleton.html#%E4%B8%BA%E4%BB%80%E4%B9%88%E6%88%91%E4%BB%AC%E4%BD%BF%E7%94%A8%E5%AE%83