单例模式（20）

今天我们来讲一下单例模式，下面我们来用winform来做一个简单的展示，就是点击一个菜单，弹出另一个窗体（做成父子窗体的形式）。

建一个窗体（父窗体），拖一个MenuStrip，再建一个窗体（子窗体）。

然后：

        private void Form1_Load(object sender, System.EventArgs e)
        {
            this.IsMdiContainer = true;
        }

        private void 工具栏ToolStripMenuItem_Click(object sender, System.EventArgs e)
        {
            Form2 form2 = new Form2();
            form2.MdiParent = this;
            form2.Show();
        }

现在，我们看一下执行结果。

我们可以看到，每次我们点击一下工具，都会弹出一个新的窗体，我们想要的结果是：之弹出一次这个窗体就行。

有些伙伴说，可以用ShowDialog() 啊，在此，说明一下，在父子窗体中，子窗体是不能用ShowDialog()出来的，再退一步讲，即便是能用ShowDialog(),但是这是一个阻塞机制，很不灵活。

那么，为了实现我们想要的结果，我们该如何做呢？

简单啊，我们只需要修改一下点击事件里的代码就可以了。

先声明一个子窗体的全局变量，然后修改一下代码：

        private Form2 form2;
        private void Form1_Load(object sender, System.EventArgs e)
        {
            this.IsMdiContainer = true;
        }

        private void 工具栏ToolStripMenuItem_Click(object sender, System.EventArgs e)
        {
            if (form2 == null)
            {
                form2 = new Form2();
                form2.MdiParent = this;
                form2.Show();
            }
        }

这样就可以实现我们想要的结果了，这样就完了嘛？

这里存在两个问题：

1、如果我有很多按钮，每个按钮都想弹出这个子窗体，想实现这个结果，需要复制粘贴这些代码，显然是很失败的做法。

2、上述结果，如果我关闭了打开的窗体，我在点击工具菜单，则不会再弹出窗体来了。（因为关闭窗体后，该窗体仅仅是Disposed了，但对象还不是null，所以判断是否为null是有一定的问题的。）

针对上述两个问题，我们来改进一下。就用到今天要讲的单例模式了，好，我们来看一下如何实现。

Form2中的代码

    public partial class Form2 : Form
    {
        //声明一个静态的类变量
        private static Form2 form2 = null;
        //构造方法私有，外部代码不能直接new来实例化它
        private Form2()
        {
            InitializeComponent();
        }
        //得到类实例的方法，返回值就是本类对象，注意也是静态的。
        public static Form2 GetForm()
        {
            //当内部的form2是null或者被Dispose过，则new它
            //并且设计其MdiParent为Form1，此时将实例化的对象存在静态的变量form2中，以后就可以不用实例化而得到它了
            if (form2 == null || form2.IsDisposed)
            {
                form2 = new Form2();
                form2.MdiParent = Form1.ActiveForm;
            }
            return form2;
        }
    }

Form1 中的调用

    public partial class Form1 : Form
    {
       
        public Form1()
        {
            InitializeComponent();
        }
    
        private void Form1_Load(object sender, System.EventArgs e)
        {
            this.IsMdiContainer = true;
        }
        private void 工具栏ToolStripMenuItem_Click(object sender, System.EventArgs e)
        {
            Form2.GetForm().Show();
        }
    }

这样，就达到了我们想要的效果了。

我们来总结一下：

单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

通常我们剋让一个全局变量是的一个对象被访问，但它不能防止你实例化多个对象。最好的办法就是，让类自身负责保存它的唯一实例，这个类可以保证没有其他实例可以被创建，并且他可以提供一个访问该实例的方法。

好，我们来写一下单例模式的代码

    class Singleton
    {
        private static Singleton instance;
        //构造方法让其private，这就堵死了外界利用用new创建次类实例的可能
        private Singleton()
        {
            
        }
        //此方法是获得本类实例的唯一全局访问点
        public static Singleton GetInstance()
        {
            //若实例不存在，则new一个新实例，否则返回已有的实例
            if (instance==null)
            {
                instance = new Singleton();
            }
            return instance;
        }
    }

客户端：

       public static void Main()
        {
            Singleton s1 = Singleton.GetInstance();
            Singleton s2 = Singleton.GetInstance();
            //比较两次实例化后对象的结果是否相同
            if (s1==s2)
            {
                Console.WriteLine("两个对象是相同的实例。");
            }
            Console.ReadKey();
        }

另外还有一个问题，如果多线程中，多个线程同时访问Singleton类，调用GetInstance()方法，会有可能创造多个实例的。所以，我们可以用lock进行处理一下。

好，我们来看用lock处理后的Singleton类

    class Singleton
    {
        private static Singleton instance;
        //程序运行时创建一个静态只读的进程辅助对象
        private static readonly object syncRoot = new object();
        //构造方法让其private，这就堵死了外界利用用new创建次类实例的可能
        private Singleton()
        {

        }
        //此方法是获得本类实例的唯一全局访问点
        public static Singleton GetInstance()
        {
            //在同一个时刻加了锁的那部分程序只有一个线程可以进入
            lock (syncRoot)
            {
                //若实例不存在，则new一个新实例，否则返回已有的实例
                if (instance == null)
                {
                    instance = new Singleton();
                }
            }
            return instance;
        }
    }

对于上述的代码，小伙伴们发现了一个问题没有，就是不管instance是不是为null，都会先加锁，这势必会影响性能的，好我们来看一下优化后的：

    class Singleton
    {
        private static Singleton instance;
        //程序运行时创建一个静态只读的进程辅助对象
        private static readonly object syncRoot = new object();
        //构造方法让其private，这就堵死了外界利用用new创建次类实例的可能
        private Singleton()
        {

        }
        //此方法是获得本类实例的唯一全局访问点
        public static Singleton GetInstance()
        {
            //先判断实例是否存在，如果不存在再加锁处理
            if (instance==null)
            {
                //在同一个时刻加了锁的那部分程序只有一个线程可以进入
                lock (syncRoot)
                {
                    //若实例不存在，则new一个新实例，否则返回已有的实例
                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                } 
            }
            return instance;
        }
    }

其实再实际应用当中，C#与用功语言运行库也提供了一种“静态初始化”方法，这种方法不需要开发人员显示的编写线程安全代码，即可解决多线程环境下他是不安全的问题。

好，下面我们来看一下“静态初始化”方法的单例模式

    //sealed阻止发生派生，而派生可能会增加实例
    public sealed class Singleton
    {
        //在第一次引用类的任何成员时创建实例，共功与原运行库负责处理变量初始化。
        private static readonly Singleton instance = new Singleton();
        private Singleton()
        {
        }

        public static Singleton GetInstance()
        {
            return instance;
        }
    }

这种静态初始化的方式是自己被加载时就将自己实例化，所以被形象的成为恶汉式单例类，原先的单例模式处理是要再第一次被引用时，才会将自己实例化，所以被称为懒汉单例类。

好，单例模式我们就介绍完了，下一篇博文我们讲 桥接模式

---

本系列将持续更新，喜欢的小伙伴可以点一下关注和推荐，谢谢大家的支持