-Begin-

前言

什么是单例模式？

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

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

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

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

如果我们创建了一个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  lazy = new Lazy (() => new China());
        public static China Instance
        {
            get
            {
                return lazy.Value;
            }
        }
    }
整体总结

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

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