单例模式攻防进阶（C#举例）

---

单例模式本身是避免类的对象多次实例化，但总会有各种花式破解之术，以懒汉式单例模式为例进行举例说明。

一般写法

    /// <summary>
    /// 懒汉式
    /// </summary>
    class Demo
    {
        private static object objLock = new object();
        private Demo() { }
        private static Demo demoItem;
        public static Demo getInstance()
        {
            if (demoItem == null)
            {
                lock (objLock)
                {
                    if (demoItem == null)
                    {
                        demoItem = new Demo();
                    }
                }
            }
            return demoItem;
        }
    }

第一次攻防（编译器优化）

demoItem = new Demo();

风险

当通过上面过程实例化的时候，其执行过程不是原子性的，至少会经过如下三个步骤：

1. 分配内存
2. 执行构造方法
3. 指向地址

由于指令重排，导致线程执行下面实例化的时候，可能跳过第二步执行了第三步，如果此时另一个线程进来，发现Demo已经不为空直接返回，并且后面使用了返回的Demo，由于第一个线程还未执行第二步，因此会导致Demo的实例不完整，可能会出现意想不到的错误。

完善

可以通过为变量增加Volatile声明，volatile 关键字指示一个字段可以由多个同时执行的线程修改，声明为 volatile 的字段不受编译器优化（假定由单个线程访问）的限制，这样可以确保该字段在任何时间呈现的都是最新的值。结果如下：

    /// <summary>
    /// 懒汉式
    /// </summary>
    class Demo
    {
        private static object objLock = new object();
        private Demo() { }
        private volatile static Demo demoItem;
        public static Demo getInstance()
        {
            if (demoItem == null)
            {
                lock (objLock)
                {
                    if (demoItem == null)
                    {
                        demoItem = new Demo();
                    }
                }
            }
            return demoItem;
        }
    }

第二次攻防（反射）

攻击

如果通过反射实例化，这可以轻松避开上面的单例，示例如下：

        static void Main(string[] args)
        {
            try
            {
                Demo item1 = Demo.getInstance();
                
                Type t = Type.GetType("single.Demo");
                ConstructorInfo[] tInfoArray= t.GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance);
                Demo item2 = (Demo)tInfoArray[0].Invoke(null); 

                Console.WriteLine(item1.GetHashCode());
                Console.WriteLine(item2.GetHashCode());

            }
            catch(Exception e)
            {
                Console.WriteLine(e.StackTrace);
            }
            Console.ReadKey();
        }

执行结果如下，从打印结果可以看出，生成了两个不同的实例：

防守

对于这种情况，只需要在构造函数中增加限制即可，在私有构造函数中如果Demo实例不为空，表示已经被创建了，如果通过正常的GetInstance调用，是不会出现问题的，因此可以直接抛出异常。修改后的代码如下：

    /// <summary>
    /// 懒汉式
    /// </summary>
    class Demo
    {
        private static object objLock = new object();
        private Demo()
        {
            lock (objLock)
            {
                if (demoItem != null)
                {
                    throw new Exception("不要试图用反射破坏单例模式");
                }
            }
        }
        private volatile static Demo demoItem;
        public static Demo getInstance()
        {
            if (demoItem == null)
            {
                lock (objLock)
                {
                    if (demoItem == null)
                    {
                        demoItem = new Demo();
                    }
                }
            }
            return demoItem;
        }
    }

第三次攻防（双反射）

攻击

上面的方案可以解决反射前已经创建实例的情况，但是如果两次都是通过反射来进行实例化，则可以绕过该判断，调用代码如下：

        static void Main(string[] args)
        {
            try
            {
                //Demo item1 = Demo.getInstance();
                
                Type t = Type.GetType("single.Demo");
                ConstructorInfo[] tInfoArray= t.GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance);
                Demo item2 = (Demo)tInfoArray[0].Invoke(null);
                Demo item3 = (Demo)tInfoArray[0].Invoke(null); 

                Console.WriteLine(item3.GetHashCode());
                Console.WriteLine(item2.GetHashCode());

            }
            catch(Exception e)
            {
                Console.WriteLine(e.StackTrace);
            }
            Console.ReadKey();
        }

防守

对于全部通过反射来绕过私有构造函数中的判断，可以增加额外的标志位进行检测和判断，代码如下：

    /// <summary>
    /// 懒汉式
    /// </summary>
    class Demo
    {
        private static bool InstanceFlag = false;
        private static object objLock = new object();
        private Demo()
        {
            lock (objLock)
            {
                if (InstanceFlag == false)
                {
                    InstanceFlag = true;
                }
                else
                {
                    throw new Exception("不要试图用反射破坏单例模式");
                }
            }
        }
        private volatile static Demo demoItem;
        public static Demo getInstance()
        {
            if (demoItem == null)
            {
                lock (objLock)
                {
                    if (demoItem == null)
                    {
                        demoItem = new Demo();
                    }
                }
            }
            return demoItem;
        }
    }

第四次攻防（反射再反射）

攻击

尽管通过标志位可以避免直接通过反射实例化多个实体，但是标志位本身是可以通过反射进行修改的，因此可以通过反射修改标志位的值来进行攻击，代码如下：

		static void Main(string[] args)
        {
            try
            {
                //Demo item1 = Demo.getInstance();
                
                Type t = Type.GetType("single.Demo");
                ConstructorInfo[] tInfoArray = t.GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance);
                Demo item2 = (Demo)tInfoArray[0].Invoke(null);
                FieldInfo field = t.GetField("InstanceFlag",BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Static);
                field.SetValue(t, false);

                Demo item3 = (Demo)tInfoArray[0].Invoke(null); 

                Console.WriteLine(item3.GetHashCode());
                Console.WriteLine(item2.GetHashCode());

            }
            catch(Exception e)
            {
                Console.WriteLine(e.StackTrace);
            }
            Console.ReadKey();
        }

防守

目前也还没想到更好的方案应对该攻击，可能，并没有一个完美的方案去避免通过反射破坏单例模式，欢迎各位留言交流。
Java可以通过枚举实现单例模式，原理是在实例化的时候，源码不允许对枚举类型实例化。