设计模式（C#）——01单例模式

推荐阅读：

•  我的CSDN
•  我的博客园
•  QQ群：704621321

      为什么要学习设计模式呢？我以前也思考过很多次这个问题，现在也还困惑。为什么我最后还是选择了学设计模式呢？因为在游戏中，用到的次数太多了，真的有必要学习了，所以我打算来好好研究一下。

      今天开始，我将与大家一起来学习设计模式，博主是做游戏的，所以我采用C#语言来与大家分享设计模式，话不多说，我们直接进入正题。

游戏开发中常用的设计模式之一单例模式

单例模式是我遇到的第一个设计模式，也是最常用到的设计模式，几乎没个游戏都会用到单例。

所谓单例，就是一个类只有一个实例。

单例模式：确保一个类只有一个实例,并提供一个全局访问点。

下面这个类图可以帮助大家更形象的理解。



下面举个两个例子来帮助大家理解单例模式的应用

1.游戏中的使用：游戏中玩家的属性，不使用单利模式可能会出现玩家死亡增加血量的情况。为此，我们引入单例，使得同一时间只允许一个实例对其操作。

2.现实中的例子：打印机，一个设备如果同时打印两个文件，会出现两个文件内容交错现象。

现在我们已经大致了解了单例模式的应用场景，那么，在游戏中我们如何实现呢？

从单例模式中我们可以总结两个要点：

（1）确保一个类只有一个实例；

（2）提供一个访问它的全局访问点；

下面通过采用两人对话的方式来帮助大家更快掌握分析思路：

菜鸟：怎样确保一个类只有一个实例了？

老鸟：那就让我帮你分析下，你创建类的实例会想到用什么方式来创建的>呢？

新手：用new关键字啊，只要new下就创建了该类的一个实例了，之后就>>可以使用该类的一些属性和实例方法了



老鸟：那你想过为什么可以使用new关键字来创建类的实例吗？



菜鸟：这个还有条件的吗？........., 哦，我想起来了，如果类定义私有的构造函数就不能在外界通过new创建实例了（注：有些初学者就会问，有时候我并没有在类中定义构造函数为什么也可以使用new来创建对象，那是因为编译器在背后做了手脚了，当编译器看到我们类中没有定义构造函数，此时编译器会帮我们生成一个公有的无参构造函数）



老鸟：不错，回答的很对，这样你的疑惑就得到解答了啊



菜鸟：那我要在哪里创建类的实例了？



老鸟：你傻啊，当然是在类里面创建了（注：这样定义私有构造函数就是上面的一个思考过程的，要创建实例，自然就要有一个变量来保存该实例把，所以就有了私有变量的声明,但是实现中是定义静态私有变量,朋友们有没有想过——这里为什么定义为静态的呢?对于这个疑问的解释为：每个线程都有自己的线程栈，定义为静态主要是为了在多线程确保类有一个实例）



菜鸟：哦，现在完全明白了，但是我还有另一个疑问——现在类实例创建在类内部，那外界如何获得该的一个实例来使用它了？



老鸟：这个，你可以定义一个公有方法或者属性来把该类的实例公开出去了（注：这样就有了公有方法的定义了，该方法就是提供方法问类的全局访问点）

菜鸟：怎样确保一个类只有一个实例了？



老鸟：那就让我帮你分析下，你创建类的实例会想到用什么方式来创建的呢？



新手：用new关键字啊，只要new下就创建了该类的一个实例了，之后就可以使用该类的一些属性和实例方法了



老鸟：那你想过为什么可以使用new关键字来创建类的实例吗？



菜鸟：这个还有条件的吗？........., 哦，我想起来了，如果类定义私有的构造函数就不能在外界通过new创建实例了（注：有些初学者就会问，有时候我并没有在类中定义构造函数为什么也可以使用new来创建对象，那是因为编译器在背后做了手脚了，当编译器看到我们类中没有定义构造函数，此时编译器会帮我们生成一个公有的无参构造函数）



老鸟：不错，回答的很对，这样你的疑惑就得到解答了啊



菜鸟：那我要在哪里创建类的实例了？



老鸟：你傻啊，当然是在类里面创建了（注：这样定义私有构造函数就是上面的一个思考过程的，要创建实例，自然就要有一个变量来保存该实例把，所以就有了私有变量的声明,但是实现中是定义静态私有变量,朋友们有没有想过——这里为什么定义为静态的呢?对于这个疑问的解释为：每个线程都有自己的线程栈，定义为静态主要是为了在多线程确保类有一个实例）



菜鸟：哦，现在完全明白了，但是我还有另一个疑问——现在类实例创建在类内部，那外界如何获得该的一个实例来使用它了？



老鸟：这个，你可以定义一个公有方法或者属性来把该类的实例公开出去了（注：这样就有了公有方法的定义了，该方法就是提供方法问类的全局访问点）

      在游戏中，就像在电影里，应该只有一个导演（游戏管理人）。游戏管理人是一个类，这个类在游戏中指挥发生的事情。它控制对象的呈现。它控制位置更新。它将玩家的输入指向正确的游戏角色。

　　      引擎应该阻止创建一个以上的游戏管理人类的实例，通过单例设计模式来实现。此设计模式确保为给定类实例化有且只有一个对象。

下面我们来看看代码怎么实现吧：

/// <summary>
    /// 单例模式的实现
    /// </summary>
    public class GameManager
    {
        // 定义一个静态变量来保存类的实例
        private static GameManager _instance;

        // 定义私有构造函数，使外界不能创建该类实例
        private GameManager()
        {
        }

        /// <summary>
        /// 定义公有方法提供一个全局访问点,同时你也可以定义公有属性来提供全局访问点
        /// </summary>
        /// <returns></returns>
        public static GameManager Instance()
        {
            // 如果类的实例不存在则创建，否则直接返回
            if (_instance== null)
            {
                _instance= new GameManager();
            }
            return _instance;
        }
    }

      注意：上述方法在单线程情况下堪称完美，但是在多线程的情况下会得到多个GameManager实例，因为在两个线程同时运行GameManager方法时，此时两个线程判断(_instance==null)这个条件时都返回真，此时两个线程就都会创建GameManager的实例。那么，这时候你可能会想到：使GameManager方法在同一时间只运行一个线程运行。

/// <summary>
    /// 单例模式的实现
    /// </summary>
    public class GameManager
    {
        // 定义一个静态变量来保存类的实例
        private static GameManager _instance;

        // 定义一个标识确保线程同步
        private static readonly object locker = new object();

        // 定义私有构造函数，使外界不能创建该类实例
        private GameManager()
        {
        }

        /// <summary>
        /// 定义公有方法提供一个全局访问点,同时你也可以定义公有属性来提供全局访问点
        /// </summary>
        /// <returns></returns>
        public static GameManager GetInstance()
        {
            // 当第一个线程运行到这里时，此时会对locker对象 "加锁"，
            // 当第二个线程运行该方法时，首先检测到locker对象为"加锁"状态，该线程就会挂起等待第一个线程解锁
            // lock语句运行完之后（即线程运行完之后）会对该对象"解锁"
            lock (locker)
            {
                // 如果类的实例不存在则创建，否则直接返回
                if (_instance== null)
                {
                    _instance= new GameManager();
                }
            }

            return _instance;
        }
    }

      上述方法可以解决多线程问题，但是对于每个线程都要加锁后判断，难免有些繁琐，在线程创建了实例后，后面的线程只需要判断是否if（_instance== null）。在lock语句前面加一句（_instance==null）的判断就可以避免锁所增加的额外开销，这种实现方式我们就叫它 “双重锁定”

	/// <summary>
    /// 单例模式的实现
    /// </summary>
    public class GameManager
    {
        // 定义一个静态变量来保存类的实例
        private static GameManager _instance;

        // 定义一个标识确保线程同步
        private static readonly object locker = new object();

        // 定义私有构造函数，使外界不能创建该类实例
        private GameManager()
        {
        }

        /// <summary>
        /// 定义公有方法提供一个全局访问点,同时你也可以定义公有属性来提供全局访问点
        /// </summary>
        /// <returns></returns>
        public static GameManager GetInstance()
        {
            // 当第一个线程运行到这里时，此时会对locker对象 "加锁"，
            // 当第二个线程运行该方法时，首先检测到locker对象为"加锁"状态，该线程就会挂起等待第一个线程解锁
            // lock语句运行完之后（即线程运行完之后）会对该对象"解锁"
            // 双重锁定只需要一句判断就可以了
            if (_instance== null)
            {
                lock (locker)
                {
                    // 如果类的实例不存在则创建，否则直接返回
                    if (_instance== null)
                    {
                        _instance= new GameManager();
                    }
                }
            }
            return _instance;
        }
    }

      看了上面的代码你或许有疑问：为什么前面判断了_instance== null，后面又判断了，你或许会觉得没必要，但是，这个是很重要的，因为这时候我们考虑的是多线程，前一时刻判断了不代表下一时刻还是该状态。