创建型模式之单例模式

简要介绍

• GoF设计模式包含5种创建型模式。 通常将一种非GoF模式——简单工厂模式作为学习其他
  工厂模式的基础。
• 单例模式：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
• 简单工厂模式：定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。
• 工厂方法模式：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。
• 抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
• 原型模式：使用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。
• 建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

1. 单例模式

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

代码实例：

public class UserModel extends BaseModel {

    private static UserModel ourInstance = null;
    public static UserModel getInstance() {
        if(ourInstance  == null)
            ourInstance  = new UserModel();
        return ourInstance;
    }
    private UserModel(){}

1.1 恶汉式单例与懒汉式单例

• 单例模式的缺点（以上面为例）：当第一次调用 getInstance()时，instance对象为null，系统要执行ourInstance = new UserModel()创建；在此过程中，由于要对UserModel进行大量的初始化工作，需要一段时间来创建对象。而在此时，如果再一次调用getInstance()（通常发生在多线程环境中）,由于instance尚未创建成功，仍然为null，代码ourInstance = new UserModel();再执行一次，导致最终创建了多个UserModel实例，违背了单例模式的原则。
• 饿汉式单例类
  类被加载时，静态变量ourInstance即被初始化，唯一的实例被创建。

public class UserModel extends BaseModel {

    private static UserModel ourInstance = new UserModel();
    public static UserModel getInstance() {
        return ourInstance;
    }
    private UserModel(){}

• 懒汉式单例类与线程锁定
  懒汉模式技术也称为“延迟加载技术”，即需要的时候再加载实例，为了避免多个线程同时调用getInstance()方法，可以使用synchronized关键字。在public static UserModel getInstance() 加了关键字synchronized进行线程锁定以处理多个线程同时访问的问题。

public class UserModel extends BaseModel {

    private static UserModel ourInstance = new UserModel();
    synchronized public static UserModel getInstance() {
        if(ourInstance  == null)
            ourInstance  = new UserModel();
        return ourInstance;
    }
    private UserModel(){}

• 懒汉模式改进
  上述代码虽然解决了线程安全问题，但是每次调用时都需要进行线程锁定判断，在多线程高并发访问环境中，将会导致系统性能大大降低。事实上我们无需对整个getInstance()进行锁定，只需要锁定ourInstance即可。

public class UserModel extends BaseModel {

    private static UserModel ourInstance = new UserModel();
    public static UserModel getInstance() {
        if(ourInstance  == null) {
            synchronized(UserModel.class) {
                ourInstance  = new UserModel();
            }
        }
        return ourInstance;
    }
    private UserModel(){}

• 懒汉模式再改进
  上述代码还是会出现多重实例的现象，因为在多线程的情况下，线程A和线程B都在调用getInstance()，加入线程A先进入synchronized(UserModel.class)，那么线程B只能在此外排队，等待线程A完成，线程B才能进入，而此时线程B并不知道A已经创建了实例，线程B还会继续创建。
  解决方法：双重检查锁定。
  注意代码中关键字volatile，被修饰的变量，可以确保多个线程都能够正确处理。但是关键字volatile会屏蔽JAVA虚拟机做一些代码优化，因此会导致系统运行效率下降，所以双重检测的懒汉模式并不是一种完美方法。

public class UserModel extends BaseModel {
    //需要加上关键字 volatile 
    private volatile static UserModel ourInstance = new UserModel();
    public static UserModel getInstance() {
        if(ourInstance  == null) { //第一次检查
            synchronized(UserModel.class) {
                if(ourInstance ==  null) //再次检查是否已经实例化
                    ourInstance  = new UserModel();
            }
        }
        return ourInstance;
    }
    private UserModel(){}

• 更好的单例实现方法 IoDH
  IoDH: Initialization on Demand Holder方法
  在单例类内部添加一个静态内部类，在该内部类中创建单例对象，再通过该单例对象通过getInstance返回给外部使用，代码如下：
  使用IoDH既实现了延迟加载，又可以保证线程安全，不影响系统性能。

public class UserModel extends BaseModel {

    private static class UserModelHolder {
        private final static UserModel instance = new UserModel();
    }
    public static UserModel getInstance() {
        return UserModelHolder.instance;
    }
    private UserModel(){}

    public static void main() {
        UserModel u1, u2;
        u1 = UserModel.getInstance();
        u2 = UserModel.getInstance();
        System.out.println(u1 == u2); //true
    }
}