设计模式之单例模式

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

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作为对象修饰符保证了对象只在第一次创建对象时候执行。

 

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