有些类也需计划生育 单例模式

21.1 类也需计划生育

21.2 判断对象是否是null

namespace 单例模式
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

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

        private FormToolbox ftb;                             //类变量声明，

        private void ToolStripMenuItemToolbox_Click(object sender, EventArgs e)
        {
            if (ftb == null || ftb.IsDisposed)              //关闭工具箱时，实例并没有变为null而只是Disposed，
            {
                ftb = new FormToolbox();
                ftb.MdiParent = this;
                ftb.Show();
            }
        }

    }
}

namespace 单例模式
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

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

        private FormToolbox ftb;

        private void ToolStripMenuItemToolbox_Click(object sender, EventArgs e)
        {
            openToolbox();
        }

        private void toolStripButton1_Click(object sender, EventArgs e)
        {
            openToolbox();
        }

        private void openToolbox()
        {
            if (ftb == null || ftb.IsDisposed)
            {
                ftb = new FormToolbox();
                ftb.MdiParent = this;
                ftb.Show();
            }
        }

    }
}

21.3 生还是不生是自己的责任

所有类都有构造函数，不编码则系统默认生成空的构造函数，若有显示定义的构造函数，默认的构造函数就会失效，将类的构造函数写成private的，外部程序就不能用new来实例化它了，

namespace 单例模式
{
    public partial class FormToolbox : Form
    {
        private static FormToolbox ftb = null;           //声明一个静态类变量，         

        private FormToolbox()                            //构造函数私有，外部代码不能直接new来实例化，         
        {
            InitializeComponent();
        }

        public static FormToolbox GetInstance()          //得到类实例的方法，返回值就是本类对象，注意也是静态的         
        {
            if (ftb == null || ftb.IsDisposed)
            {
                ftb = new FormToolbox();                 //当内部的ftb是null或被Dispose过，则new它，
                ftb.MdiParent = Form1.ActiveForm;        //并且设计其Mdiparent为Form1，此时将实例化的对象存在静态变量ftb中，
            }                                            //以后就可以不用实例化得到它了，
            return ftb;
        }

    }
}

namespace 单例模式
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

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

        private void ToolStripMenuItemToolbox_Click(object sender, EventArgs e)
        {
            FormToolbox.GetInstance().Show();
        }

        private void toolStripButton1_Click(object sender, EventArgs e)
        {
            FormToolbox.GetInstance().Show();
        }

    }
}

这样一来，客户端不在考虑是否需要去实例化的问题，而把责任都给了应该负责的类去处理，其实这就是单例模式，

21.4 单例模式

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

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

namespace 单例模式
{
    class Program
    {
        static void Main(string[] args)
        {
            Singleton s1 = Singleton.GetInstance();
            Singleton s2 = Singleton.GetInstance();

            if (s1 == s2)                                      //比较两次实例化后对象的结果是实例相同，
            {
                Console.WriteLine("Objects are the same instance");
            }

            Console.Read();
        }
    }


    class Singleton
    {
        private static Singleton instance;

        private static readonly object syncRoot = new object();

        private Singleton()                                    //构造函数让其private，堵死外界利用new创建实例的可能，
        {

        }

        public static Singleton GetInstance()                  //此方法是获得本类实例的唯一全局访问点，
        {
            if (instance == null)                              //若实例不存在，则new一个新实例，否则返回已有实例，
            {
                instance = new Singleton();
            }
            return instance;
        }
    }

单例模式除了可以保证唯一的实例外，它还可以严格的控制客户怎样访问它以及何时访问它，简单的说就是对唯一实例的受控访问，

21.5 多线程时的单例

多线程的程序中，多个线程同时访问Singleton类，调用GetInstance方法，会有可能造成创建多个实例，

可以给进程一把锁来处理，lock是确保当一个线程位于代码的临界区时，另一个线程不能进入临界区，如果其它线程试图进入锁定的代码，则它将一直等待即被阻止，直到该对象被释放，

class Singleton
{
    private static Singleton instance;

    private static readonly object syncRoot = new object();//加锁时，instance实例有没有被创建过都还不知道，无法对其加锁，

    private Singleton()                                    //构造函数让其private，堵死外界利用new创建实例的可能，
    {

    }

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

21.6 双重锁定

class Singleton
{
    private static Singleton instance;

    private static readonly object syncRoot = new object();//加锁时，instance实例有没有被创建过都还不知道，无法对其加锁，

    private Singleton()                                    //构造函数让其private，堵死外界利用new创建实例的可能，
    {

    }

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

当instance为nul并且同时有两个线程调用GetInstance方法时，它们都可以通过第一重instance==null的判断，然后由于lock机制，两个线程则只有一个进入，另一个在外排队等候，必须要其中的一个进入并出来后，另一个才能进入，而此时如果没有了第二重的instance是否判断为null的判断，则第一个线程创建了实例，而第二个线程还是可以继续再创建新的实例，这就没有达到单例的目的，

21.7 静态初始化

C#与公共语言运行库也提供了一种“静态初始化”方法，这种方法不需要开发人员显示的编写线程安全代码，即可解决多线程环境下它是不安全的问题，

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

    private Singleton() { }

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

这样的实现与前面的示例类似，也是解决了单例模式试图解决的两个基本问题，全局访问和实例化控制，公共静态属性为访问实例提供了一个全局的访问点，不同之处在于它依赖公共语言运行库来初始化变量，由于构造函数时私有的，因此不能在类本身以外实例化Singleton类，因此，变量引用的是可以在系统中唯一存在的实例，注意instance变量标记为readonly。意味着只能在静态初始化期间或在类构造函数中分配变量，由于静态初始化的方式是在自己被加载时就将自己实例化，所以被形象称为饿汉单例模式，原先的单例模式处理方式是要在第一次被引用时，才会将自己实例化，所以称之为懒汉单例模式，

其区别为，饿汉式即静态初始化的方式，它是类一加载就实例化的对象，所以要提前占用系统资源，而懒汉式又会面临着多线程访问的安全性问题，需要双重锁定这样的处理才可以保证安全，