单例的实现方法总结

2019-09-28 本文已影响0人白花蛇草可乐

单例的实现方法总结

以下的内容不涉及基础，比如什么是单例？JVM类加载顺序？等等。

仅仅是对所有单例的实现方法进行汇总。

一、最经典的饿汉模式实现方式

public class Singleton1 {
    private final static Singleton1 INSTANCE = new Singleton1();
    private Singleton1(){
    }
    public static Singleton1 getInstance() {
        return INSTANCE;
    }
}

另外一个变种的实现方法，是将静态成员改为静态代码块

public class Singleton1_2 {
    private static Singleton1_2 instance;
    static {
        instance = new Singleton1_2();
    }
    private Singleton1_2 (){}
    public static Singleton1_2 getInstance() {
        return instance;
    }
}

不管怎么写，本质上利用的都是“类的初始化过程（包含静态成员赋值，以及静态代码块的执行），只在类被加载到内存时执行一次”这一特性。

优点

由于其原理，天然就是线程安全的
结构简单理解容易

缺点

相对于懒汉模式，饿汉模式最麻烦的地方在于，如果创建单例类的对象要依赖参数或者外部配置文件的话，也就是说，业务场景需要在调用getInstance方法时传入参数，决定用何种方式创建单例实例的话，饿汉模式就无法使用了。

二、懒汉模式实现方法

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

优点

在必须使用延迟加载的场景下，替代饿汉模式

缺点

最重要的一点，为了确保线程安全，必须使用synchronized关键字进行同步，影响性能。

三、双重检查方法

双重检查其实就是对于懒汉模式的一种性能改进，减小了synchronized关键字锁定的代码块范围。
第二重检查的作用是：防止有别的线程，在第一重检查和拿锁之间创建了单例实例。

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

四、静态内部类方法

这种方法，也是利用了类加载的特性，在getInstance()方法调用静态内部类的静态成员变量时，静态内部类SingletonHolder才会被初始化，创建单例实例。
（复习：使用 Class.staticMember 方式引用类的静态成员变量，属于对类进行主动引用，在这种情况下会触发类加载的初始化过程）

public class Singleton4 {
    private static class SingletonHolder {
        private static final Singleton4 INSTANCE = new Singleton4();
    }
    private Singleton4 (){
    }
    public static Singleton4 getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

优点

延迟加载
无锁，没有性能损耗
天然线程安全

五、枚举类

这是一种最简洁但是最难理解的单例实现方法。但是《Effective Java》评价这是实现单例的最佳方法（参看该书第3条）

public enum Singleton5 {
    /**
     * 枚举实现单例
     */
    INSTANCE;
    public void businessMethod() {
    }
}

其调用方法如下：

Singleton5.INSTANCE.businessMethod()

下面解释枚举类为什么能实现单例。

首先对于Singleton5编译好的class进行反编译

因为enum只是一个关键字，不是超类或者其他能看到源码的东西。因此利用反编译的手段来确认内部实现（可以使用jad等工具）。

package singleton;


public final class Singleton5 extends Enum
{

    public static Singleton5[] values()
    {
        return (Singleton5[])$VALUES.clone();
    }

    public static Singleton5 valueOf(String name)
    {
        return (Singleton5)Enum.valueOf(singleton/Singleton5, name);
    }

    private Singleton5(String s, int i)
    {
        super(s, i);
    }

    public void businessMethod()
    {
    }

    public static final Singleton5 INSTANCE;
    private static final Singleton5 $VALUES[];

    static 
    {
        INSTANCE = new Singleton5("INSTANCE", 0);
        $VALUES = (new Singleton5[] {
            INSTANCE
        });
    }
}

枚举如何保证线程安全

可以看到，使用enum关键字的话，实际会生成一个继承了Enum，并且final的类。

public final class Singleton5 extends Enum

注意下面的这一段：

    public static final Singleton5 INSTANCE;
    private static final Singleton5 $VALUES[];

    static 
    {
        INSTANCE = new Singleton5("INSTANCE", 0);
        $VALUES = (new Singleton5[] {
            INSTANCE
        });
    }

根据类加载过程，在“链接”的“准备”阶段，静态且final的静态成员INSTANCE被加载到了方法区（如果这里有赋值操作的话就有值了，不会等到初始化阶段，这是final与其他不同的地方）。
到了初始化阶段，会执行静态代码块内的内容，开辟内存空间存放单例实例，并将地址赋值给INSTANCE。
类加载过程是只会执行一次的，所以本质上还是利用jvm规定的类加载过程，形成了天然的线程安全
另外，构造函数 new Singleton5("INSTANCE", 0) 实际上调用是 super，也就是 Enum 类的构造函数，第一个参数是枚举名称(name)，第二个参数是顺序(ordinal)。

解决反序列化问题

前面除了枚举类以外的单例的实现方法，都有一个弱点，如果需要进行序列化的话（implements Serializable），那么在反序列化的时候，每次调用readObject()方法都会生成一个不同于原单例的新实例，单例失效。
对于枚举，为了保证枚举类型符合Java相关规范（JSR），每一个枚举类及其定义的枚举变量在JVM中都是唯一的，在枚举类型的序列化和反序列化上，Java有特殊处理
序列化的时候，Java仅将枚举类的name属性输出到结果中，反序列化的时候通过Enum的valueOf方法来根据名字查找枚举对象。

    public static <T extends Enum<T>> T valueOf(Class<T> enumType,
                                                String name) {
        T result = enumType.enumConstantDirectory().get(name);
        if (result != null)
            return result;
        if (name == null)
            throw new NullPointerException("Name is null");
        throw new IllegalArgumentException(
            "No enum constant " + enumType.getCanonicalName() + "." + name);
    }

而valueOf()调用enumConstantDirectory()，继而调用getEnumConstantsShared()，可以看到里面实际调用的是反编译出来的那段代码里的value()方法，使用的实际上就是那个$VALUES[]。

    Map<String, T> enumConstantDirectory() {
        if (enumConstantDirectory == null) {
            T[] universe = getEnumConstantsShared();
            if (universe == null)
                throw new IllegalArgumentException(
                    getName() + " is not an enum type");
            Map<String, T> m = new HashMap<>(2 * universe.length);
            for (T constant : universe)
                m.put(((Enum<?>)constant).name(), constant);
            enumConstantDirectory = m;
        }
        return enumConstantDirectory;
    }

    T[] getEnumConstantsShared() {
        if (enumConstants == null) {
            if (!isEnum()) return null;
            try {
                final Method values = getMethod("values");
                java.security.AccessController.doPrivileged(
                    new java.security.PrivilegedAction<Void>() {
                        public Void run() {
                                values.setAccessible(true);
                                return null;
                            }
                        });
                @SuppressWarnings("unchecked")
                T[] temporaryConstants = (T[])values.invoke(null);
                enumConstants = temporaryConstants;
            }
            // These can happen when users concoct enum-like classes
            // that don't comply with the enum spec.
            catch (InvocationTargetException | NoSuchMethodException |
                   IllegalAccessException ex) { return null; }
        }
        return enumConstants;
    }

所以枚举即使被反序列化也不会创建对象。
所以枚举即使被反序列化也不会创建对象。
所以枚举即使被反序列化也不会创建对象。

六、应对多个类加载器

前面的所有方法都有一个共通的问题：被多个类加载器加载。

这问题不算是钻牛角尖，一些热启动机制的框架，就是利用多个类加载器实现的，这时候确实有可能造成单例变成多例。

在网上找到了一段代码来解决这个问题，就是增加下面这个私有静态类。

原理是在被调用getClass方法时，直接利用自身原来的类加载器进行类加载，确保自始至终一直是同一个类加载器在加载单例类。

private static Class getClass(String classname) throws ClassNotFoundException {     
      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();     
      
      if(classLoader == null)     
         classLoader = Singleton.class.getClassLoader();     
      
      return (classLoader.loadClass(classname));     
   }     
}

单例的实现方法总结