设计模式：单例模式（至少有一种你没有见过）

背景

本文中的例子多是从《clr via c#》中抄袭而来，读过这本书最后一章的朋友，应该见过各种实现了。

各种实现

第一种：简单版本

代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesignPatternStudy.Creations.Singletons
{
    class SimpleSingleton
    {
        private static readonly SimpleSingleton _instance;

        private SimpleSingleton() { }

        static SimpleSingleton()
        {
            _instance = new SimpleSingleton();
        }

        public static SimpleSingleton Singleton
        {
            get
            {
                return _instance;
            }
        }
    }
}

说明：静态构造方法是线程安全的，因此可以保证单例。如果单例类型有其它静态方法，调用这些方法会导致单例被初始化。

第二种：嵌套类

代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesignPatternStudy.Creations.Singletons
{
    class NestedSingleton
    {
        private NestedSingleton() { }

        public static NestedSingleton Singleton
        {
            get
            {
                return Nested._instance;
            }
        }

        public static void OtherStaticMethod()
        {
            Console.WriteLine("不会产生单例！");
        }

        private class Nested
        {
            public static readonly NestedSingleton _instance;

            static Nested()
            {
                _instance = new NestedSingleton();
            }
        }
    }
}

说明：解决了“简单版本”的问题，调用单例类型的静态方法不会导致单例被实例化。

第三种：双校验+悲观锁

代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesignPatternStudy.Creations.Singletons
{
    class DoubleCheckSingleton
    {
        private static readonly Object _lock = new Object();
        private static DoubleCheckSingleton _instance;

        private DoubleCheckSingleton() { }

        public static DoubleCheckSingleton Singleton
        {
            get
            {
                if (_instance != null)
                {
                    return _instance;
                }

                lock (_lock)
                {
                    if (_instance == null)
                    {
                        _instance = new DoubleCheckSingleton();
                    }
                }

                return _instance;
            }
        }
    }
}

说明：设计模式的作者使用的语言是 C++，C++ 没有和 C# 静态构造方法同样语义的机制，因此使用了这种双校验机制。

第四种：双校验+乐观锁

代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

namespace DesignPatternStudy.Creations.Singletons
{
    class CASSingleton
    {
        private static CASSingleton _instance;

        private CASSingleton()
        {
            Console.WriteLine("CASSingleton");
        }

        public static CASSingleton Singleton
        {
            get
            {
                if (_instance != null)
                {
                    return _instance;
                }

                Interlocked.CompareExchange(ref _instance, new CASSingleton(), null);  // 相当于：update xxx_table set version = new_version where version = old_version

                return _instance;
            }
        }
    }
}

说明：乐观锁在某些情况下是比悲观锁好用，在本例中有一点要求：构造方法的执行必须没有副作用，因为内部可能创建多个实例，外部只会看到一个。

备注

看完大师的书籍，觉得自己好渺小，继续努力吧。