设计模式之单例模式

在程序中如果希望某一个对象(类或者是窗体等任何的对象)只创建一次也就是至始至终使用同一个实例，那么我们就会用到了单例模式，对于单例模式有两种方式可以实现：

1.私有构造函数+私有静态对象实例+公有访问方法

  class MySingle
    {
        //控制线程加锁对象
        private static readonly object obj = new object();
        //私有对象实例
        private static MySingle instance;
        /// <summary>
        /// 私有构造函数
        /// </summary>
        private MySingle()
        {
        }

        /// <summary>
        /// 共有访问函数
        /// </summary>
        /// <returns></returns>
        public static MySingle GetInstance()
        {
            if (instance == null)
            {
                lock (obj)
                {
                    if (instance == null)
                    {
                        instance = new MySingle();
                    }
                }
            }
            return instance;
        }
    }

使用方法:

 MySingle single = MySingle.GetInstance();

 只所以添加lock判断是防止多线程的时候同样是可以创建多个对象的，另外为了防止每次代码都执行lock这样耗费性能的代码，所以仅在对象为空的时候才进行lock锁。

2.私有构造函数+公有静态对象实例(次方法和方法1本质一样)

   class MySingle
    {
        //控制线程加锁对象
        private static readonly object obj = new object();
        private static MySingle _instance;
        public static MySingle Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (obj)
                    {
                        if (_instance == null)
                        {
                            _instance = new MySingle();
                        }
                    }
                }
                return _instance;
            }
        }
        /// <summary>
        /// 私有构造函数
        /// </summary>
        private MySingle()
        {
        }
    }

同样私有构造函数，然后使用了一个public的对象替代了方法1中的公有函数，感觉这样在使用起来更方便，其他没有做变动，使用方法:

  MySingle single1 = MySingle.Instance;

 3.密封类+私有静态只读对象实例+公有方法

 sealed class MySingle
    {
        private static readonly MySingle _instance=new MySingle ();
     
        /// <summary>
        /// 私有构造函数
        /// </summary>
        private MySingle()
        {
        }

        public static MySingle GetInstance()
        {
            return _instance;
        }
    }

定义密封类是防止派生其他类，而派生类可能会增加实例；使用readonly作为对象修饰符保证了对象只在第一次创建对象时候执行。

当然，上述只是提出了比较常用的形式实现单例模式，大家有更好的可以互相交流。