旧瓶装新酒的单例模式

单例模式大家都不陌生。即在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问。
在应用的时候 ，我们可以把它比喻成一个小桥。
A同学为了游泳，建立了一个泳池，这个泳池可以其他人也用。这样B同学在游泳就不用再自己建一个泳池了。

那么我们来说一下如何保证单例模式的唯一性。

①平常的类我们都是通过调用其类的构造方法来创建。如classA tem=new ClassA();
为了保证类不能被其他类多次创建。我们设计成让其构造方法私有化。
于是我们写成这个样子

    public class Single
    {
        //私有构造方法，外类不能访问了，但是自己本类可以访问
        private Single() { }
        //自己本类的成员位置，创建自己的本类对象 

        private Single single = new Single();

        //提高公共方法，返回成员变量single
        public Single GetInstance()
        {
            return single;
        }

    }

但是这样问题又出现了，由于我们不能new 对象，因此调用方法制成另一种唯一的方法就是类名调用。

    public class Single
    {
        //私有构造方法，外类不能访问了，但是自己本类可以访问
        private Single() { }
        //自己本类的成员位置，创建自己的本类对象 

        private static  Single single = new Single();

        //提供公共方法，返回成员变量single
        public static  Single GetInstance()
        {
            return single;
        }

    }

我们通过Static 关键字来实现调用问题。
以上这一种，在实例化时就已经创建了该对象，因此我们称之为饿汉式单例模式。

那么另一种与之对应的是在我们需要的时候再去创建该对象。称之为懒汉式单例模式。
如图。

    public class Single
    {
        private Single() { }
        private static Single single = null;//此处定义静态成员变量但是不创建对象

        //提供公共方法，返回对象
        public static Single GetInstance()
        {
            if (single == null)
            {
                //创建对象
                single = new Single();
            }
            return single;
        }

    }

到这里我们还是和之前的学习是一致的。但是我们通常做的系统都是高性能的并发程序。因此，在来看上面这一部分代码的时候，就会察觉出一个非常危险的地方。
那就是，假如当前A类中调用单例，在判断为空之后还没有创建该单例的间隙隙，又有一个类也要调用单例，这是犹豫A类 还没有创建，所以B类也执行到了Single single=new Single() 语句，因此单例被创建了两次。

为了避免多线程出现这种情况，我们可以将其设置为同步。即当前若有一个类对单例进行操作时，不允许其他类再次进行操作。于是我们可以对其加一把锁。

  public class Single
    {
        private Single() { }
        private static Single single = null;
        static object obj = new object();//用于锁
        public static Single GetInstance()
        {
            lock (obj)//新加入的锁
            {
                if (single == null)
                {
                    single = new Single();
                }
                return single;
            }

        }

    }

到这里本可以大功告成了。但是仔细读读 上面的代码，我们 会发现每次到该类的时候都要先进行锁操作然后再去判断等，如果调用频繁的话，反复的锁和开锁是非常耗费资源的。于是，为了对此进行优化，我们又进行了一层判断。

    public class Single
    {
        private Single() { }
        private static Single single = null;
        static object obj = new object();//用于锁
        public static Single GetInstance()
        {
            if (single == null)//新进行的判断
            {
                lock (obj)
                {
                    if (single == null)
                    {
                        single = new Single();
                    }

                }
            }
            return single;
        }

    }

如此，安全与高性能同在。代码就是需要 一步的推敲和研究和不断的去 优化和设计。其实，我们写的每一行代码又何尝不是如此。作为一名优秀的程序员，我们要始终抱着一个工匠人的心态去不断的打磨和雕琢我们的代码，只有这样，才能一步步将其 设计成非常有美感的艺术品。

昨天去参加一个技术大会，一个演讲人说他们公司的招聘语只有一句。

快速的写出性能非常好的高质量 可靠代码