设计模式之4--单例模式

单例模式

实际开发过程中，有时候需要确保系统中某个类只有唯一一个实例，当这个唯一的实例创建成功之后，我们无法再创建同类型的其他对象，之后所有操作都是基于这个唯一的实例。为了实现这个目标，我们下面就学习下单例模式。

为了实现类的唯一性，我们需要三个步骤对普通的类进行修改。

1. 一般创建对象都是调用new来实例化某个类，为了确保实例的唯一性我们需要禁止类的外部使用new来创建对象，那么就需要把构造函数设置private属性。
2. 当把构造函数设置为private后，类的外部无法再创建对象，但是在类的内部还是可以创建的。因此我们在类的内部创建并保存这个唯一的实例。所以需要在类的内部定义一个静态的私有变量。
3. 最后为了保证成员变量的封装行，我们把定义的私有变量的可见性也设置为private，同时增加一个公有的静态方法，通过静态方法返回创建的私有变量。

单例模式定义：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类成为单例类，它提供全局访问的方法。单例模式是一种对象创建型模式

单例模式有三个要点：一是类只有一个实例；而是它必须自行穿件这个实例；三是它必须自行向整个系统提供这个实例。

上图是单例模式的结构图，图中我们可以看到构造函数Singleton()和静态成员instance都是私有private的，而只有一个GetInstance()是public的，这个方法提供给系统来访问得到唯一的实例对象。

实现代码如下

class Singleton {
    private static Singleton instance = null;
    private Singleton() {};

    public static Singleton getInstance() {
            if(instance == null)
                instance = new Singletion();
            return instance;
    }
}

现在我们知道了单例模式设计的要点，但是后来人们在实际开发过程中发现按照上述代码实现的话系统中可能还是会存在多个类实例，而这个是怎么发生的呢？

原来在第一次调用getInstance方法的时候，判断instance为null那么就会执行new Singleton()的代码，但是在创建Singleton对象的时候需要执行大量的初始化工程，而如果在这个时候再次去调用getInstance方法的话，由于此时instance还未创建成功仍然为null的，就会导致new Singleton()再次被执行。这就导致了系统中还是有可能会存在多个实例，违背了单例模式的初衷。为了解决这个问题，后来大牛们又找到了解决方法。

1. 饿汉式单例类

   饿汉式单例类会在类加载的时候就去创建实例对象

   class EagerSingleton {
       private static final EagerSingletion instance = new Singleton();
       private EagerSingleton(){};
   
       public static EagerSingleton getInstance() {
           return instance;
       }
   
   }    

2. 懒汉式单例类

   上面介绍的饿汉式单例模式在类加载的时候就会去创建实例对象，这个对象会长期存在于内存中，而不考虑系统到底是否需要使用。而懒汉式单例类则是将创建对象的行为延后，等到系统调用getInstance()真正获取该实例对象执行的时候才会去创建对象。但是考虑迟到多个线程同时访问的问题，可以使用synchronized关键字。

   class LazySingleton {
       private static LazySingleton instalce = null
       private LazySingleton(){ };
   
       synchronized public static LazySingleton getInstance() {
           if(instance == null)
               instance = new LazySingleton();
           return instance;
       }
   }

   上面的方法通过synchronized关键字进行同步，但是在多线程高并发的环境下在每次调用getInstance的时候就会进行线程锁定判断，这会导致系统性能大大降低。因此我们不必对getInstance整个方法进行锁定，而只是需要对new LazySingleton()代码进行锁定就好了。

   public static LazySingleton getInstance(){
       if(instance == null) {
           synchronized(LazySingleton.class) {
               instance = new LazySingleton();
           }
       }
   }

   通过上面的方法貌似系统性能降低的问题解决了，但是实际上这种设计方法还是会导致系统中存在多个实例对象，没有真正的做到唯一，原因还是一个线程A在创建对象的时候，另一个线程B会因为synchronized而等待，但是等到A线程创建结束之后，B不知道对象已经创建过了，还是会进入到new的阶段。因此这里进一步修改，设计一种称为双重检查锁定的方法。

   class LazySingleton {
       private volatile static LazySingleton instance = null;
       private LazySingleton() { };
   
       public static LazySingleton getInstance() {
           //第一重判断
           if(instance == null) {
               synchronized(LazySingleton.class) {
                   //第二重判断
                   if(instance == null)
                       instance = new LazySingleton();
               }
           }
           return instance;
       }
   }

   双重检查锁定的方法需要设置静态私有变量为volatile属性，保证变量被多个线程正确处理。

上面主要描述了饿汉式单例模式和懒汉式单例模式的实现方法，而它们也是各有优缺点的。饿汉式单例模式在类加载的时候就会创建实例对象，那么这势必导致加载过程时间变长，并且无论系统是否真正使用该对象，类的对象已经被创建了，消耗了系统资源。而懒汉式单例模式是推迟到执行的时候才去创建对象，那么这就需要同步好多个线程访问的情况，保证系统中始终存在一个实例对象，为了同步进行的线程锁定，也势必会影响到系统的性能。

下面我们介绍一个更好的单例实现方法，我们在单例类中增加一个静态内部类，在该内部类创建单例对象，再将该单例对象通过getInstance方法返回给外部使用。Initialization on Demand Holder(IoDH)

class Singleton {
    private Singleton() {} ;

    private static class HolderClass {
        private final static Singleton instance = new Singleton();
    }

    public static Singleton getInstance() {
        return HolderClass.instance;
    }

    public static void main(String args[]) {
        Singleton s1,s2;
        s1 = Singleton.getInstance();
        s2 = Singleton.getInstance();
    }
}

通过静态内部类的实现方式，我们将创建对象的时间延后，因为单例对象没有作为Singleton的成员，因此类加载的时候不会实例化。而在第一次调用getInstance的时候会加载HolderClass内部类，在内部类中有一个instance的成员变量，那么这时候才会去创建Singleton对象，由Java虚拟机来保证线程安全性，确保成员变量只初始化一次。

总结：
单例模式提供了对唯一实例的受控访问，保证实例对象在系统中是唯一的，对于一些需要频繁创建和销毁的对象以及消耗大量资源的对象来说单例对象可以提高系统的性能。
同时基于单例模式我们还可以扩展成可变数目的实例。

缺点：
单例模式没有抽象层，因此扩展很麻烦。
对于Java这种由垃圾自动回收的语言，如果单例对象长时间不被使用，那么可能会被系统回收，下次使用的时候再重新实例化，这就会导致之前的单例对象状态丢失。

适用场景：

1. 系统只需要一个实例对象，或者需要消耗资源太大而只允许创建一个对象。
2. 客户端调用类的单个实例只能通过一个公共访问点，而不能通过其它途径访问该实例。