单例模式

一. 两种模式

懒汉模式

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

• 以时间换空间

饿汉模式

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

• 以空间换时间

二. 单例模式的实现

双重锁检测机制

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

注意：instance = new Singleton（）的时候的指令重排，会导致线程B如果此时

正确版本

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

violate关键字阻止了instance的指令重排

静态内部类实现单利模式

public class SingleTon {
    private static class LazyMan {
        private static SingleTon INSTANCE = new SingleTon();
    }
    
    public static SingleTon getInstance(){
        return LazyMan.INSTANCE;
    }
}

枚举类实现单例模式

非枚举类的缺陷

利用反射打破单例模式

//获得构造器
Constructor con = Singleton.class.getDeclaredConstructor();
//设置为可访问
con.setAccessible(true);
//构造两个不同的对象
Singleton singleton1 = (Singleton)con.newInstance();
Singleton singleton2 = (Singleton)con.newInstance();
//验证是否是不同对象
System.out.println(singleton1.equals(singleton2));//false

以上代码可以简化为三步：

• 获取单例的构造器
• 把构造器设置为可访问
• 使用newinstance方法构造对象

用枚举类实现单例模式

public enum SingletonEnum {
    INSTANCE;
}

JVM会组织反射获取枚举类的私有方法

继续进行以下测试

//获得构造器
Constructor con = SingletonEnum.class.getDeclaredConstructor();
//设置为可访问
con.setAccessible(true);
//构造两个不同的对象
SingletonEnum singleton1 = (SingletonEnum)con.newInstance();
SingletonEnum singleton2 = (SingletonEnum)con.newInstance();
//验证是否是不同对象
System.out.println(singleton1.equals(singleton2));

那么这个时候就会抛出异常

xception in thread "main" java.lang.NoSuchMethodException: com.xiaohui.singleton.test.SingletonEnum.<init>()

at java.lang.Class.getConstructor0(Class.java:2892)

at java.lang.Class.getDeclaredConstructor(Class.java:2058)

at com.xiaohui.singleton.test.SingletonTest.main(SingletonTest.java:22)

at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)

at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

at java.lang.reflect.Method.invoke(Method.java:606)

at com.intellij.rt.execution.application.AppMain.main(AppMain.java:134)

3种单例模式的总结


三. 关于静态内部类实现单例模式

静态内部类的优点
外部类加载时并不需要立即加载内部类，内部类不会被加载则不会去初始化INSTANCE，故不占内存。也就是当Singleton第一次被加载时，并不需要去加载Singleton，只有当getInstance（）昂发第一次被调用时，才回去初始化INSTANCE，第一次调用getInstance（）方法会导致虚拟机加载Singleton类。

对于初始化阶段，虚拟机严格规范了有且只有6种情况下，必须对类进行初始化(只有主动去使用类才会初始化类)：

• 当遇到 new 、 getstatic、putstatic或invokestatic 这4条直接码指令时，比如 new 一个类，读取一个静态字段(未被 final 修饰)、或调用一个类的静态方法时。
  • 当jvm执行new指令时会初始化类。即当程序创建一个类的实例对象。
  • 当jvm执行getstatic指令时会初始化类。即程序访问类的静态变量(不是静态常量，常量会被加载到运行时常量池)。
  • 当jvm执行putstatic指令时会初始化类。即程序给类的静态变量赋值。
  • 当jvm执行invokestatic指令时会初始化类。即程序调用类的静态方法。
• 使用 java.lang.reflect 包的方法对类进行反射调用时如Class.forname("…"),newInstance()等等。 ，如果类没初始化，需要触发其初始化。
• 初始化一个类，如果其父类还未初始化，则先触发该父类的初始化。
• 当虚拟机启动时，用户需要定义一个要执行的主类 (包含 main 方法的那个类)，虚拟机会先初始化这个类。
• MethodHandle和VarHandle可以看作是轻量级的反射调用机制，而要想使用这2个调用， 就必须先使用findStaticVarHandle来初始化要调用的类。
• 当一个接口中定义了JDK8新加入的默认方法（被default关键字修饰的接口方法）时，如果有这个接口的实现类发生了初始化，那该接口要在其之前被初始化。

这6种情况被称为是类的主动引用，并且《虚拟机规范》使用的限定词是"有且仅有"，那么除此之外的所有引用类都不会对类进行初始化，称为被动引用。静态内部类就属于被动引用。

如何实现单例、懒加载、线程安全

• 单例模式
  • 静态变量随着类的加载只执行一次
• 懒加载
  • 当getInstance()方法被调用时，静态内部类才在外部类的运行时常量池里，把符号引用替换为直接引用，这时静态对象INSTANCE也真正被创建
• 线程安全
  • 静态内部类的的初始化过程，虚拟机会保证一个类的()方法在多线程环境中被正确枷锁、同步

参考：
漫画讲述单例模式https://zhuanlan.zhihu.com/p/33102022
深入讲述静态内部类原理[https://www.cnblogs.com/wuzaipei/p/10974561.html](