单例的几种实现方式：懒汉、饿汉、DLC、内部类单例、枚举单例

饿汉

public class Hungry{
    private Hungry(){}
    private static final Hungry hungry = new Hungry();
    public static Hungry getInstance(){
        return hungry;
    }
}

缺点：占用空间，被调用之前都仍占用内存

懒汉

public class Lazy {
    private Lazy(){
    	//调用下线程名，看哪几个线程获得了对象
        System.out.println(Thread.currentThread().getName());
    };
    private static  Lazy lazy = null;
    public static Lazy getInstance(){
        if(lazy==null){
            lazy = new Lazy();
        }
        return lazy;
    }
	//用十条多线程测试下
    public static void main(String[] args) {
        for(int i = 0;i<10;i++){
            new Thread(()->{
                Lazy.getInstance();
            }).start();
        }
    }
}

结果显示在多线程情况下不安全

双重验证懒汉式—DCL

public class Lazy {
    private Lazy(){
        System.out.println(Thread.currentThread().getName());
    };
    //添加volatile关键字阻止指令重排
    private volatile static Lazy lazy = null;
    
    public static Lazy getInstance() {
        if (lazy == null) {
            synchronized (Lazy.class) {
                if (lazy == null) {
                    lazy = new Lazy();
                }
            }
        }
        return lazy;
    }
    public  static void main(String[] args) {
        for(int i = 0;i<10;i++){
            new Thread(()->{
                Lazy.getInstance();
                //执行顺序：
                //1分配内存空间
                //2初始化对象
                //3将对象指向内存空间 
                //因为此操作不是原子性操作，可能发生指令重排，造成空指针异常
            }).start();
        }
    }
}

//但仍可通过反射机制破解，可以升级为多重验证，如下
public class Lazy {
    private static boolean one = false;//加强一下，三重验证
    private Lazy() {
         //此处也可以加个锁
             if(!one){
                one=true;
            }else {
                 //抛个异常终止反射
                throw new RuntimeException("再搞破坏把你抓起来！");
            }
        }  
    private volatile static Lazy lazy = null;
    public static Lazy getInstance() {
        if (lazy == null) {
            synchronized (Lazy.class) {
                if (lazy == null) {
                    lazy = new Lazy();         
                }
            }
        }
        return lazy;
    }

    public static void main(String[] args) throws Exception {
        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        //通过反射创建对象
        Lazy lazy1 = declaredConstructor.newInstance();
        Lazy lazy2 = declaredConstructor.newInstance();
        //输出两个对象的hashcode--不一致，说明单例被破坏
        System.out.println(lazy1.hashCode());
        System.out.println(lazy2.hashCode());
		//多重验证后会报异常--再搞破坏把你抓起来！
    }
}

静态内部类单例

静态内部类只有类中属性被调用时才开始加载，可以节省资源

public class InnerSingle{
    private InnerSingle(){}
    private static class Inner{
      private static final InnerSingle innerSingle = new InnerSingle();
    }
    public static InnerSingle getInstance(){
        return Inner.innerSingle;
    }
}

静态内部类单例线程安全，并且是懒加载，但仍可被反射破解,那我们进反射源码看看情况

public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            //不可通过反射创建枚举类
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }

根据反射源码得知，枚举类不可被破坏

枚举单例

public enum EnumSingleton {

    INSTANCE;

    public void method() {
        System.out.println("这是一个枚举方法");
    }
}

//调用方式
public class Main {
    public static void main(String[] args) {
        EnumSingleton.INSTANCE.method();
    }

}