前言

什么是单例模式？

单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例（根据需要，也有可能一个线程中属于单例，如：仅线程上下文内使用同一个实例）

上面是百度百科给出的解释。

大家都知道，面向对象的思想就是我们可以把一个类实例很多次，每次实例出来的都是一个对象，意味着你可以创建很多个基于这个类的对象。

单例模式，说白了，就是这些对象本质都是同一个，整个程序中，不管在哪里用，使用的都是同一个实例对象。

如果我们创建了一个China类，我们可以一直new吗？不可以，因为世界上只有一个China，所以我们使用的都是同一个China对象。

Version 1 - 非线程安全

    public class China

    {

        private China()

        {

        }

        private static China china = null;

        public static China Instance

        {

            get

            {

                if (china == null)

                {

                    Console.WriteLine("实例化对象");

                    china = new China();

                }

                return china;

            }

        }

    }

最简单的实现方式如上图，创建一个私有的静态对象和私有构造方法，然后在CreateInstance方法里，加一个判断，如果为Null，就重新实例化一下，否则直接返回。

这种写法从逻辑上是没问题的，但是是否会出现这个if (china == null)判断，同时执行，这样就麻烦了。

所以这种写法在单线程的程序是没问题的，但是在多线程中，是可能会有问题的。

我们做个测试，测试代码如下：

    class Program

    {

        static void Main(string[] args)

        {

            for (int i = 0; i < 10; i++)

            {

                new TaskFactory().StartNew(() =>

                {

                    China china =  China.Instance;

                });

                Thread.Sleep(10);

            }

            Console.ReadLine();

        }

    }

上面的代码，就是创建10个线程，都执行CreatInstance方法，那么最终是输出多少次Console.WriteLine("实例化对象")呢？

我们测试发现，这个输出结果是不唯一的，有时候会输出5次，有时候会输出2次，但是一般都是超过1次，这个就说明对象被多次实例化了，这就违背了单例模式的原则。

Version 2 - 简单的线程安全

既然出现问题，那么我们就需要做一下优化，优化之后的代码如下：

    public class China

    {

        private China()

        {

        }

        private static China china = null;

        private static object objlock = new object();

        public static China Instance

        {

            get

            {

                lock (objlock)

                {

                    Console.WriteLine("执行判断");

                    if (china == null)

                    {

                        Console.WriteLine("实例化对象");

                        china = new China();

                    }

                }

                return china;

            }

        }

    }

对比看下，就是加了一个同步锁，这样就可以避免同时执行的情况，并且，我们在lock里加了一个Console.WriteLine("执行判断")，观察这行代码执行多少次。

从结果来看，实例化对象只执行了一次，说明对象只被创建过一次，满足了我们的需求，达到了预期的效果。

Version 3 - 双if+lock实现

上面那种方式已经可以达到预期效果，但是我们注意到一个问题，执行判断这行代码被执行了10次，这显示不符合我们的逻辑，既然已经实例化了，为什么每次还要执行判断呢？是不是多此一举？并且每次请求对象，都会进行lock操作，lock对性能是有一定影响的。

于是我们继续优化，优化之后的代码如下：

    public class China

    {

        private China()

        {

        }

        private static China china = null;

        private static object objlock = new object();

        public static China Instance

        {

            get

            {

                if (china == null)

                {

                    lock (objlock)

                    {

                        Console.WriteLine("执行判断");

                        if (china == null)

                        {

                            Console.WriteLine("实例化对象");

                            china = new China();

                        }

                    }

                }

                return china;

            }

        }

    }

我们对比代码可以看出，就是又加了一个if (china == null)，这种双if+lock的方式，是不是可以解决我们的问题呢？

我们执行一次，看看结果：

我们通过结果可以看到只执行了一次判断，也只执行一次实例化对象，但是我们还可以继续优化。

Version 4 - 静态变量实现

话不多说，直接上代码：

    public class China

    {

        private China()

        {

        }

        private static readonly China china = new China();

        public static China Instance

        {

            get

            {

                return china;

            }

        }

    }

利用静态变量去实现单例，非常简单，但同时也是线程安全的，由CLR保证，在程序第一次使用该类之前被调用，而且只调用一次。

但是这种方式也有缺点，就是实例化过程是在程序初始化时就执行的，而不是在使用时才执行，就是说，不管你用不用，都已经实例化了。

Version 5 - 完全懒汉式实现

    public class China

    {

        private China()

        {

        }

        public static China Instance

        {

            get

            {

                return Lazy.instance;

            }

        }

        private class Lazy

        {

            static Lazy()

            {

            }

            internal static readonly China instance = new China();

        }

    }

这种方法与上一种方法类似，只是多加了一个类，来解决上一个版本的缺点。

Version 6 - 使用Lazy特性

从.NET 4开始，可以使用Lazytype来实现完全懒汉式，代码也变得更简单，代码如下：

    public class China

    {

        private China()

        {

        }

        private static readonly Lazy<China> lazy = new Lazy<China>(() => new China());

        public static China Instance

        {

            get

            {

                return lazy.Value;

            }

        }

    }

整体总结

可能大家看完之后，选择困难症又会犯了吧？

这里给大家总结一下，除了Version 1，其他几种情况，均可以实现单例模式，一般情况下我们使用Vesion 2和Version 4比较多，虽然Version 2会浪费一定的资源，但是很容易理解，实际应用中，影响不会很大。