浅谈单例模式

前言

什么是单例模式？

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

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

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

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

如果我们创建了一个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;}}}