单例模式（20）

82602411

2017-02-13

今天我们来讲一下单例模式，下面我们来用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();
         }

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

单例模式（20）

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

有些伙伴说，可以用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;
         }
     }

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

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

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

单例模式窗体