Singleton模式

属于创建型模式，它是意图是保证一个类只有一个实例，然后需要给外部客户程序一个统一的访问入口。 在创建了该实例以后所有的使用都是使用的之前常见的类，隐藏了该类型的实现细节，并且需要的话可以持久化该实例， 保持实例的状态。

    public class Singleton
    {
        private Singleton(){}

        private static volatile Singleton instance = null;

        public static Singleton Instance
        {
            get
            {
                if (instance == null)
                {
                    lock (typeof(Singleton))
                    {
                        if (instance == null)
                        {
                            instance = new Singleton();
                        }
                    }
                }

                return instance;
            }
        }
    }

 

传统的的double check在创建的时候，用到了lock，在大部分时间以内（第一次创建之后），每次都要锁定，大大降低的相率。 在.Net 环境下 最简洁，常用的Singleton

    public class Singleton
    {
        private Singleton(){}

        private static readonly Singleton instance = new Singleton();

        public static Singleton Instance
        {
            get
            {
                return instance;
            }
        }
    }

这种常用的singleton，如果只需要调用其静态方法，或属性而基本不需要调用实例方法的话，这样无故创建了一个实例，就会浪费内存。

用单例模式的计数器：

public class SingletonCounter
    {
        private SingletonCounter() { }

        private static readonly SingletonCounter instance = new SingletonCounter();

        private int count = 0;

        public static SingletonCounter Instance
        {
            get
            {
                return instance;
            }
        }

        public int Next
        {
            get
            {
                return Interlocked.Increment(ref count);
            }
        }
    }

 

由单个实例引申为固定的多个实例：

public class SingletonN
    {
        private SingletonN() { }

        private static readonly int MaxInstanceCount = 5;
        private static List<SingletonN> singletonPool = new List<SingletonN>(MaxInstanceCount);

        private bool isBusy = false;
        /// <summary>
        /// 释放实例，回到实例池中
        /// </summary>
        public void Release()
        {
            isBusy = false;
        }

        public static SingletonN Instance
        {
            get
            {
                lock (typeof(SingletonN))
                {
                    SingletonN instance = null;

                    foreach (SingletonN s in singletonPool)
                    {
                        if (!s.isBusy)
                        {
                            instance = s;
                            break;
                        }
                    }

                    if (instance == null)
                    {
                        if (singletonPool.Count >= MaxInstanceCount)
                        {
                            return null;
                        }
                        else
                        {
                            instance = new SingletonN();
                            singletonPool.Add(instance);
                        }
                    }

                    instance.isBusy = true;
                    return instance;
                }
            }
        }
    }