设计模式之单例模式，六种实现，以及反射破解

在介绍设计模式之前，先贴一下设计模式的三种类型，和六大原则。

• 创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
• 结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。
• 行为型模式（11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

设计模式的六原则

• 开闭原则：对扩展开放,对修改关闭
• 里氏代换原则：任何基类可以出现的地方,子类一定可以出现,(子类代换基类)
• 依赖倒转原则：对接口编程,依赖于抽象,而不依赖于具体
• 接口隔离原则：使用多个隔离的接口,比使用单个好,降低耦合度
• 合成复用原则：尽量使用合成/聚合的方式，而不是使用继承
• 迪米特法则（最少知道原则）：实体之间尽量少发生相互作用,使模块相对独立

下面开始介绍最简单常见的单例模式

使用场景：一个类全局只有一个实例的情况。该实例由单例类自己创建，并提供访问该实例的方法。使用单例类一般是实例创建比较复杂的情况，且对象不保存状态信息（即没有可供修改的成员变量，否则很容易被修改）。可以将单例类理解成一个工具类，提供全局访问，只有一个实例。Spring中的bean默认使用的就是单例模式。

下面开始介绍单例模式的六种实现

饿汉模式

饿汉模式是在类被加载的时候就创建了实例，即使这个单例都不一定会被使用。

public class Singleton{
    private Singleton(){}    // 构造方法私有化
    private static final Singleton instance = new Singleton();       // 实例在类加载时就被创建 
    public static Singleton getInstance(){
        return instance;
    }
}

懒汉模式

懒汉模式是在只有单例类被使用的时候才创建出来。

public class Singleton {
	private Singleton(){}
	private static Singleton instance = null;	// 默认为null
	public static Singleton getInstance(){
		if (instance == null) {				// 方法被调用的时候才创建
			instance = new Singleton();
		}
        return instance;
    }
}

线程安全的懒汉模式

在多线程环境下，上面的懒汉模式，很容易创建出多个实例。于是需要加锁。加一个synchronized就不会有多线程创建多个实例了。

public class Singleton {
	private Singleton(){}
	private static Singleton instance = null;	// 默认为null
	public static synchronized Singleton getInstance(){
		if (instance == null) {				// 方法被调用的时候才创建
			instance = new Singleton();
		}
        return instance;
    }
}

双重检验锁 的懒汉模式

既然是多线程环境下，直接在方法上加synchronized，那效率就很低了，肯定不满足要求。所以需要在内部创建对象的时候才加锁。

但是看下面的代码，我们发现在获取到锁开始创建对象前，又进行了一次非空校验。这个应该很好理解吧，在创建时加锁只是让线程一个一个进去。两个线程同时访问，第一个获取到锁的线程进去创建了实例后，第二个进入，如果不判空，第二个还是会创建另一个实例。双重校验锁在平时写代码中很常见（划重点）

然后其实只有一个应该注意的是 volatile 关键字，该关键字能够防止java指令重排序。instance = new Singleton();在jvm中包含多个操作（划分一块内存 ->在内存上创建对象 -> 将instance指向对应内存等），然后进过jvm重排序后，可能就是 (划分一块内存 -> 将instance指向对应内存等 -> 在内存上创建对象) 这样的话，就会返回一个没有实例化完全的对象了，比如null。

public class Singleton {
    private Singleton(){}
    private static volatile Singleton instance = null;
    public static synchronized Singleton getInstance(){
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

静态内部类模式 （登记式）

这种方法也是在使用时才实例化。但看代码里面貌似直接new了。这是利用了静态内部类的特性，只有在访问静态内部类时，它才会被加载。

public class Singleton{
    private static class Inner{
        private static final Singleton instance= new Singleton();
    }
    private Singleton();
    public static Singleton getInstance(){        //调用该方法时,Inner类才会被加载,然后实例化instance
        return Inner.instance; 
    }
}

枚举类模式

最简单粗暴的方式当然是我们的枚举类了。都不需要写getInstance方法，直接 Singleton.instance 访问。

public enum Singleton{
    instance;
}

这样咋一看，感觉枚举类和饿汉模式差不多嘛。不不不，在反射面前，前面5中模式都是渣渣。只有枚举类不能通过反射修改构造方法。

public static void main(String[] args)  {
   Class<Singleton> aClass = Singleton.class;
    try {
        Constructor<Singleton> constructor = aClass.getDeclaredConstructor();
        constructor.setAccessible(true);
        Singleton singleton = constructor.newInstance();
        Singleton singleton2 = constructor.newInstance();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

然后看到有人说，加一个类变量，然后调用构造方法时判断其状态，如果时第二次就抛异常。比如下面这样

public class Singleton {
    private static boolean init = false;
    private Singleton(){
        if (init) {
            throw new RuntimeException();
        }
        init = true;
        System.out.println("hahah");
    }
    private static Singleton instance = new Singleton();

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

天真！以为反射只能修改构造方法的可见性？

public static void main(String[] args)  {
    Class<Singleton> aClass = Singleton.class;
    try {
        Constructor<Singleton> constructor = aClass.getDeclaredConstructor();
        constructor.setAccessible(true);
        Field init = aClass.getDeclaredField("init");
        init.setAccessible(true);
        init.setBoolean(null, false);
        Singleton singleton = constructor.newInstance();
        init.setBoolean(null, false);
        Singleton singleton2 = constructor.newInstance();
    } catch (Exception e) {
        e.printStackTrace();
    }
}