剑指offer之面试题2：实现Singleton模式

来源：剑指offer

这篇主要记录《剑指offer》书籍中的面试题2：实现Singleton模式

使用语言：C# 

代码环境：VS2017

总共有5中解法，从前往后依次优化。

结构如下：

前言

这里先给出调用程序的代码

Program.cs

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            //Task.Run(() =>
            //{
            //    Console.WriteLine(Singleton1.Instance);
            //});
            //Task.Run(() =>
            //{
            //    Console.WriteLine(Singleton1.Instance);
            //});


            //Task.Run(() =>
            //{
            //    Console.WriteLine(Singleton2.Instance);
            //});
            //Task.Run(() =>
            //{
            //    Console.WriteLine(Singleton2.Instance);
            //});

            //Task.Run(() =>
            //{
            //    Console.WriteLine(Singleton3.Instance);
            //});
            //Task.Run(() =>
            //{
            //    Console.WriteLine(Singleton3.Instance);
            //});

            //Task.Run(() =>
            //{
            //    Console.WriteLine(Singleton4.Instance);
            //});
            //Task.Run(() =>
            //{
            //    Console.WriteLine(Singleton4.Instance);
            //});
           

            Task.Run(() =>
            {
                Console.WriteLine(Singleton5.Instance);
            });
            Task.Run(() =>
            {
                Console.WriteLine(Singleton5.Instance);
            });
            Console.ReadKey();

        }
    }

这里，会在每次创建一种Singleton模式的实现方法之后，在这里调用。

里面会用两个线程来模拟多线程的情况。

而在单例的实现中，会在创建构造函数时，输出语句，来区别是否创建了多个对象。

效果如下示例：

构造函数只调用了一次。

方法一

单线程情况下的一般实现。

代码如下：

Singleton1.cs

    public sealed class Singleton1
    {
        //私有的构造函数
        private Singleton1()
        {
            //Console.WriteLine($"Singleton1生成了...{Guid.NewGuid()}");
        }
        private static Singleton1 instance = null;
        /// <summary>
        /// 在静态属性Instance中，只有在instance为null时，才创建一个实例以避免重复
        /// </summary>
        public static Singleton1 Instance
        {
            get
            {
                //如果instance为空，则创建实例
                if (instance == null)
                {
                    //Thread.Sleep(3000);  //模拟多线程同时到达这里
                    instance = new Singleton1();
                }
                return instance;
            }
        }
    }

在上述代码中，Singleton1的静态属性Instance中，只有在instance为null的时候才创建一个实例以避免重复创建。

同时我们把构造函数定义为私有函数，这个就可以确保只创建一个实例。

但是这种方法只适合单线程，多线程情况下，就有问题了。

方法二

为了保证多线程环境下，我们还是只能得到一个类型的实例，需要加上一个同步锁。

代码如下：

Singleton2.cs

    public sealed class Singleton2
    {
        /// <summary>
        /// 私有的构造函数
        /// </summary>
        private Singleton2()
        {
            Console.WriteLine($"Singleton2生成了...{Guid.NewGuid()}");
        }
        //用作同步锁
        private static readonly object syncObj = new object();

        private static Singleton2 instance = null;


        public static Singleton2 Instance
        {
            get
            {
                //添加同步锁
                lock (syncObj)
                {
                    //如果instance为null,则新建
                    if (instance == null)
                    {
                        Thread.Sleep(3000);
                        instance = new Singleton2();
                    }
                      
                }
                return instance;
            }
        }
    }

我们还是假设有两个线程同时想创建一个实例。由于在一个时刻只有一个线程能得到同步锁，

当第一个线程加上锁时，第二个线程只能等待。当第一个线程创建出实例之后，第二个线程就不会重复创建实例了，

这样就保证了我们在多线程环境中也只能得到一个实例。

但是呢，这种方法也不完美。我们每次通过属性Instance得到Singleton2的实例，都会试图加上一个同步锁，

而加锁时一个非常耗时的操作，在没有必要的时候我们应该尽量避免。

方法三

我们可以这样：加同步锁前后两次判断实例是否已经存在。

我们只是在实例还没有创建之前需要加锁操作，以保证只有一个线程创建出实例。而当实例已经创建之后，我们已经不需要再做加锁操作了。

改进代码如下：

Singleton3.cs

    public sealed class Singleton3
    {
        //私有构造函数
        private Singleton3()
        {
            Console.WriteLine($"Singleton3生成了...{Guid.NewGuid()}");
        }
        //创建同步锁对象
        private static readonly object syncObj = new object();

        private static Singleton3 instance = null;

        public static Singleton3 Instance
        {
            get
            {
                //instance为null,这里可能有两个线程同时到达，即都判断为null的情况
                if (instance == null)
                {
                    Thread.Sleep(3000); //会同时有两个线程等在这里
                    //加上同步锁，即只放一个线程过去
                    lock (syncObj)
                    {
                        //如果此时instance还未null，则新建instance;否则，跳过
                        if(instance==null)
                            instance = new Singleton3();
                    }
                }
                return instance;
            }
        }
    }

这样的代码实现起来比较复杂，容易出错，我们还有更优秀的解法。

方法四

C# 语法中有一个函数能够保证只调用一次，那就是静态构造函数。

代码如下：

Singleton4.cs

     public sealed class Singleton4
    {
        static Singleton4() //静态构造函数
        {
            Console.WriteLine($"Singleton4生成了...{Guid.NewGuid()}");
        }

        private static Singleton4 instance = new Singleton4();
        
        public static Singleton4 Instance
        {
            get
            {
                Thread.Sleep(3000);
                return instance;
            }
        }
    }

 由于C# 是在调用静态构造函数时初始化静态变量，.NET运行时能够确保只调用一次静态构造函数，这样我们就能够保证只初始化一次instance。

C#中调用静态构造函数的时机不是由程序员掌控的，而是当.NET运行时，发现第一次使用一个类型的时候自动调用该类型的静态构造函数。

方法五

这种方法实现的Singleton，可以很好的解决 方法四 中Singleton4的实例创建时机过早的问题：

    public sealed class Singleton5
    {
        Singleton5()
        {
            Console.WriteLine($"Singleton5生成了...{Guid.NewGuid()}");
        }

        public static Singleton5 Instance
        {
            get
            {
                return Nested.instance;
            }
        }

        class Nested
        {
            static Nested()
            {

            }
            internal static readonly Singleton5 instance = new Singleton5();
        }
    }

在这段代码中，我们在内部定义了一个私有类型的 Nested。

当我们第一次用到这个嵌套类型的时候，会调用静态构造函数创建Singleton5的实例 instance。

类型Nested只在属性Singleton5.Instance中被用到，由于其私有属性，他人无法使用Nested类型。

因此，当我们第一次试图通过属性Singleton5.Instance得到Singleton5的实例时，会自动调用Nested的静态构造函数创建实例 instance。

总结

推荐解法，方法四，或者方法五

其中方法四利用了C#的静态构造函数的特性，确保只创建一个实例。

第五种方法利用了私有嵌套类型的特性，做到只在需要的时候才会创建实例，提高空间使用率。