考的好不好？-单例模式来解答

版权声明：本文为博主原创文章，未经博主同意不得转载。 https://blog.csdn.net/huo065000/article/details/24486185

前言：

      从小就非常反感考试。由于每次考试完无论是谁，碰见你的第一句问候语就是：考试考得怎么样啊？期末成绩出来了吗？……所以从小就非常害怕成绩单的出现，由于成绩单仅仅要不出现，自己就能够任意编篡，问自己考得怎么样？当然往好里说吧！还行吧！挺好的……

    由于考试考得好不好。是由自己内心来推断的，考得好，我当然希望告诉他人；可是考得不好，我也不想让他人知道。所以仅仅要蒙混过关就可！

    这样就谈到了今天的主题-单例模式，某件事情我仅仅想让他出现一次，而非每次点击都出现，这就是所谓的实例化，实例化与否的过程事实上就是和考试考得好不好的过程一样，应该由自己来推断，要勇于承担责任，这才是当今一代的学习楷模。

定义：

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

方法：

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

结构图：

优点：

1）保证唯一的实例

2）单例模式由于Singleton类封装它的唯一实例，这样它能够严格地控制客户如何訪问它以及何时訪问它，简单点就是对唯一实例的受控訪问。

多线程单例：

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

解决的方法：给进程加一把锁来处理。

   Lock：是确保一个线程位于代码的临界区时，还有一个线程不进入临界区。假设其它线程视图进入锁定的代码，则它将一直等待（即被组织）直到该对象被释放。

      

 class Singleton
    {
        private static Singleton instance;
        //程序执行时创建一个静态仅仅读的进程辅助对象
        private static readonly object syncRoot = new object();
        private Singleton ()
        {
        }
        public static Singleton GetInstance()
        {
            lock (syncRoot )    //在同一个时刻加了锁的那部分程序仅仅有一个线程能够进入
            {
                if (instance ==null )
                {
                    instance = new Singleton();
                }
            }
            return instance;
        }

     这段代码使得对象实例由最先进入的那个线程创建，以后的线程在进入时不会再去创建对象实例了。可是instance有没有被创建过实例根本不知道，所以优化之后：

public static Singleton GetInstance()
        {
            if (instance == null)   //先推断实例是否存在，不存在再加锁处理
            {
                lock (syncRoot)    //在同一个时刻加了锁的那部分程序仅仅有一个线程能够进入
                {
                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }

构建方式：

饿汉式单例类
懒汉式单例类

    懒汉式单例类在单例类被载入的时候。就实例化一个对象交给自己的应用。而懒汉式在调用取得实例方法的时候才会实例化对象。代码例如以下：

懒汉式：

public sealed class Singleton  //阻止发生派生。而派生可能会添加实例
        {
            private static class Singleton
            {
                //在第一次引用类的不论什么成员时创建实例。公共语言执行库负责处理变量初始化
                private static readonly Singleton instance = new Singleton();
                private Singleton() { }
                public static Singleton GetInstance()
                {
                    return instance;
                }
            }

饿汉式：

public class Singleton  //阻止发生派生，而派生可能会添加实例
        {
            private static class Singleton=null ;
            {
                private Singleton() { }
                public static  synchronized synchronized GetInstance()
                {
                    if (Singleton ==null )
                    {
                        Singleton = new Singleton();
                    }
                    return instance;
                }
            }

      对于懒汉和饿汉的使用，由于饿汉式，即静态初始化的方式，它是类一载入就实例化的对象，所以要提前占用系统资源。然而懒汉式又要面临着多线程訪问的安全性问题，须要做双重锁定这种处理才干够保证安全。

所以至于使用哪种方式。应该取决于实际的需求。

可是从c#的角度来看。饿汉式单例类应能够满足我们的需求。

单例模式与静态类

     总认为单例模式有点像一个有用类的静态方法。那么有些什么差别呢？来细致分析一下：

1）单例模式相比静态类的优势：单例能够继承类，实现接口，而静态类不能。单例能够被延迟初始化。静态类一般在第一次载入是初始化；单例类能够被集成，他的方法能够被覆写。

2）静态方法中产生的对象。会随着静态方法执行完成而而释放掉。并且执行类中的静态方法时，不会实例化静态方法所在的类

3）在不存在比較复杂的事务管理。用Singleton比較好。