设计模式系列(五)--单例模式详解，面试只要看这一篇文章就够了！

01、概念

一、概念

    1.定义：保证一个类仅有一个实例，并提供一个全局访问点。

    2.类型：创建型。

    3.适用场景：想确保任何情况下都绝对只有一个实例。

    4.优点：a.在内存里只有一个实例，减少了内存开销；b.可以避免对资源的多重占用；c.设置全局访问点，严格控制访问。

    5.重点：a.私有改造器；b.线程安全；c.延迟加载；d.序列化和反序列化安全；e.反射。

    6.根据重点需要考虑的点：

 1.如何防止外部调用new关键字来创建新的对象。

 2.如何做到防止通过对象序列化来创建新的对象。

 3.实现了cloneable的类，如何防止clone来创建新的对象。

 4.如何防止反射调用构造器来创建新的对象。

 5.如何做到线程安全。

 

二、单例模式的结构

    单例模式的主要角色如下。

    单例类：包含一个实例且能自行创建这个实例的类。

    访问类：使用单例的类。

02、模式讲解

1.懒汉模式

    这个模式，主要考虑两点：a.线程安全；b.反射破坏单列模式。

/** *@author 繁荣Aaron */public class LazySingleton {    private static LazySingleton lazySingleton = null;    private LazySingleton(){        if(lazySingleton != null){            throw new RuntimeException("单例构造器禁止反射调用");        }    }    public synchronized static LazySingleton getInstance(){        if(lazySingleton == null){            lazySingleton = new LazySingleton();        }        return lazySingleton;    } }

    首先通过私有化构造器，禁止了外部new的可能性，然后instance是static修饰的，所以在类被首次加载后，调用init 的时候，instance会被初始化，JVM保证类加载过程的线程安全，所以instance也是线程安全的。

    因为在类加载初始化的时候，单例就被创建出来了，所以相对于按需延时加载，这种写法如果有大量单例需要创建，在系统刚启动时内存压力比较大。

    线程安全，可以在方法上加上synchronized。

public synchronized static LazySingleton getInstance(){        if(lazySingleton == null){            lazySingleton = new LazySingleton();        }        return lazySingleton;    }

    反射，可以直接抛出异常处理。

 

private LazySingleton(){        if(lazySingleton != null){            throw new RuntimeException("单例构造器禁止反射调用");        }    }

 

2.DoubleCheck双重检查模式

    ​​​​​​​

/** *@author 繁荣Aaron */public class LazyDoubleCheckSingleton {    private volatile static LazyDoubleCheckSingleton lazyDoubleCheckSingleton = null;    private LazyDoubleCheckSingleton(){
    }    public static LazyDoubleCheckSingleton getInstance(){        if(lazyDoubleCheckSingleton == null){            synchronized (LazyDoubleCheckSingleton.class){                if(lazyDoubleCheckSingleton == null){                    lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton();                    //1.分配内存给这个对象//                  //3.设置lazyDoubleCheckSingleton 指向刚分配的内存地址                    //2.初始化对象//                    intra-thread semantics//                    ---------------//3.设置lazyDoubleCheckSingleton 指向刚分配的内存地址                }            }        }        return lazyDoubleCheckSingleton;    }}

    这也是很经典的单例实现，通过二次判空检查，而且只有在第一次初始化时getInstance会加锁，后面的获取都不会加锁，时间和空间效率都很高。

    这里要注意的一点是instance一定要加volatile修饰符。

alloc lazyDoubleCheckSingleton （堆上分配内存）

lazyDoubleCheckSingleton init    （对象初始化）

instance = lazyDoubleCheckSingleton

    注意，alloc必须首先执行，但是init 和第三条 赋值语句，JVM并没有做定义，也就是说如果不加volatile，它们可以被重排序。一旦被重排序，线程B在获取instance时，有可能获取到的instance还没有执行init，这就是一次很危险的调用。但是加上volatile关键字，在jdk1.5之后，就不会再有这个问题了。

 

3.静态内部类模式

/** *@author 繁荣Aaron */public class StaticInnerClassSingleton {    private static class InnerClass{        private static StaticInnerClassSingleton staticInnerClassSingleton = new StaticInnerClassSingleton();    }    public static StaticInnerClassSingleton getInstance(){        return InnerClass.staticInnerClassSingleton;    }    private StaticInnerClassSingleton(){        if(InnerClass.staticInnerClassSingleton != null){            throw new RuntimeException("单例构造器禁止反射调用");        }    }}

    静态内部类的方式实现的单例同样是线程安全的，由JDK来保证。同时也具有延时加载的特性。这个推荐使用。

 

4.饿汉式模式

/** *@author 繁荣Aaron */public class HungrySingleton implements Serializable,Cloneable{
    private final static HungrySingleton hungrySingleton;
    static{        hungrySingleton = new HungrySingleton();    }    private HungrySingleton(){        if(hungrySingleton != null){            throw new RuntimeException("单例构造器禁止反射调用");        }    }    public static HungrySingleton getInstance(){        return hungrySingleton;    }
    private Object readResolve(){        return hungrySingleton;    }
    @Override    protected Object clone() throws CloneNotSupportedException {        return getInstance();    }}

    这个模式，里面有两个方法，一个是readResolve()和clone()。第一个主要解决的是序列化的问题，第二个是解决原型设计模式的时候，拷贝的问题。

    这个模式我们将在后面解决序列化和反射问题进行详细介绍。

 

5.Enum枚举单例

/** *@author 繁荣Aaron */public enum EnumInstance {    INSTANCE{        protected  void printTest(){            System.out.println("繁荣Aaron Print Test");        }    };    protected abstract void printTest();    private Object data;
    public Object getData() {        return data;    }
    public void setData(Object data) {        this.data = data;    }    public static EnumInstance getInstance(){        return INSTANCE;    }
}-------------------------------//最简单的方式public enum EnumInstance {    INSTANCE; }

    枚举模式的构造器也是私有的，同时有个一个static final 的INSTANCE类常量，可以大胆猜测，JVM在加载枚举类时，会给所有的枚举项赋值，同时会保证过程的线程安全。

03、如何防止单例被破坏

1.解决对象序列化的问题

    解决方式：

 private Object readResolve(){        return hungrySingleton;    }

    原理解析：

​​​​​​​

public final Object readObject()        throws IOException, ClassNotFoundException    {        if (enableOverride) {            return readObjectOverride();        }         // if nested read, passHandle contains handle of enclosing object        int outerHandle = passHandle;        try {            // TODO 从这里查看            Object obj = readObject0(false);            handles.markDependency(outerHandle, passHandle);            ClassNotFoundException ex = handles.lookupException(passHandle);            if (ex != null) {                throw ex;            }            if (depth == 0) {                vlist.doCallbacks();            }            return obj;        } finally {            passHandle = outerHandle;            if (closed && depth == 0) {                clear();            }        }    } // ObjectInputStream#readObject0private Object readObject0(boolean unshared) throws IOException {    ...    case TC_OBJECT:         return checkResolve(readOrdinaryObject(unshared));    ...} // ObjectInputStream#readOrdinaryObjectprivate Object readOrdinaryObject(boolean unshared){    ...    obj = desc.isInstantiable() ? desc.newInstance() : null;    ... } // ObjectInputStream#isInstantiable 返回 true，执行 desc.newInstance()，通过反射创建新的单例类，// 到此时也看到了为什么在 HungrySingleton 没添加 readResolve 方法之前会返回新的对象./** * Returns true if represented class is serializable/externalizable and can * be instantiated by the serialization runtime--i.e., if it is * externalizable and defines a public no-arg constructor, or if it is * non-externalizable and its first non-serializable superclass defines an * accessible no-arg constructor.  Otherwise, returns false. */boolean isInstantiable() {    requireInitialized();    return (cons != null);} // ObjectInputStream#readOrdinaryObjectprivate Object readOrdinaryObject(boolean unshared){    ...    // 在 HungrySingleton 添加 readResolve 方法之后 desc.hasReadResolveMethod() 该方法执行为 true    if (obj != null &&            handles.lookupException(passHandle) == null &&            desc.hasReadResolveMethod())        {            // 通过反射调用 HungrySingleton 类中的 readResolve 方法返回，            // 即为我们的单例对象，所以这里讲此处返回的对象赋值给 obj，所以这里我们找到了答案            Object rep = desc.invokeReadResolve(obj);            if (unshared && rep.getClass().isArray()) {                rep = cloneArray(rep);            }            if (rep != obj) {                // Filter the replacement object                if (rep != null) {                    if (rep.getClass().isArray()) {                        filterCheck(rep.getClass(), Array.getLength(rep));                    } else {                        filterCheck(rep.getClass(), -1);                    }                }                handles.setObject(passHandle, obj = rep);            }        }         return obj;} // readResolveMethod = getInheritableMethod(                        // 这里有 readResolve 解答了我们 HungrySingleton 类中方法命名疑惑                        cl, "readResolve", null, Object.class);

 

2.解决反射的问题

    现象：

 /** * 反射攻击解决方案及原理 * 破坏原理：通过反射暴力访问 * 解决原理：在单例类的私有化构造方法中添加防放射破坏代码,如果是通过反射调用就抛出运行时异常 */public class Test {    public static void main(String[] args) throws Exception {        Class objectClass = HungrySingleton.class;        Constructor constructor = objectClass.getDeclaredConstructor();        HungrySingleton instance = HungrySingleton.getInstance();         constructor.setAccessible(true);        HungrySingleton object = (HungrySingleton) constructor.newInstance();         System.out.println(instance);        System.out.println(object);        System.out.println(instance == object);            }}

    运行之后的结果：

    解决方式：

  private HungrySingleton(){        if(hungrySingleton != null){            throw new RuntimeException("单例构造器禁止反射调用");        }    }

    注意：在私有化构造器中添加防止通过反射调用的代码（只针对在类加载初始化时就已经创建好单例对象的单例模式有效）即（饿汉式和基于内部类实现懒加载的单例模式有效，对其他懒加载无效）。

    如果开发者真的使用反射来作恶，谁能拦得住呢?虽然反射最终调用的还是我们的私有构造器，在构造器里面我们可以加一些判断逻辑，但是还是不能涵盖所有的情况，因为毕竟我们的单例实现多种多样，有延时加载的，有非延时加载的。

    但是通过Enum方式实现的单例是不能够被反射的，如果尝试反射Enum的构造器，会抛出一个异常，所以Enum方式实现的单例对反射安全。

 

3.解决clone的问题

    尽量不要给单例实现cloneable接口，如果非要实现，也在重写的clone方法里，返回此单例对象。

 @Override    protected Object clone() throws CloneNotSupportedException {        return getInstance();    }
/**

 * 通过原型模式的克隆方法破坏单例 */public class Test {    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {         HungrySingleton hungrySingleton = HungrySingleton.getInstance();         Method method = hungrySingleton.getClass().getDeclaredMethod("clone");        method.setAccessible(true);        HungrySingleton cloneHungrySingleton = (HungrySingleton) method.invoke(hungrySingleton);         System.out.println(hungrySingleton);        System.out.println(cloneHungrySingleton);        System.out.println(hungrySingleton == cloneHungrySingleton);               /**         * 添加相关代码，解决克隆破坏单例，再次运行         * 运行结果：              * true         */    }}

 

04

源码解读

    1.spring源码中有一个AbstractFactoryBean类，该类中有一个方法getObject()方法。

@Override  public final T getObject() throws Exception {    if (isSingleton()) {      return (this.initialized ? this.singletonInstance : getEarlySingletonInstance());    }    else {      return createInstance();    }  }

    2.mybatis中的ErrorContext类。