16、JUC：单例模式

饿汉式 DCL懒汉式 深究！

16.1、饿汉式

package com.chen.single;

// 饿汉式单例
public class Hungry {

    // 可能会浪费空间
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];

    private Hungry(){};

    private final  static  Hungry HUNGRY = new Hungry();

    public static Hungry getInstance(){
        return new Hungry();
    }
}

16.2、DCL懒汉式

package com.chen.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

// 懒汉式单例模式
public class LazyMan {

    private static boolean  flag = false;

    private LazyMan(){
        synchronized (LazyMan.class){
            if (flag == false){
                flag = true;
            } else {
                throw new RuntimeException("不要试图用反射破坏异常");
            }
        }
    }

    private volatile static LazyMan lazyMan;

    public static LazyMan getInstance(){

        // 双重检测锁模式的 懒汉式单例 DCL懒汉式
        if (lazyMan == null){
            synchronized (LazyMan.class){
                if (lazyMan == null){
                    lazyMan = new LazyMan(); // 它不是一个原子性操作
                }
            }
        }
        return lazyMan;
    }

    // 反射
    public static void main(String[] args) throws Exception {

        // LazyMan instance = LazyMan.getInstance();

        Field flag = LazyMan.class.getDeclaredField("flag");
        flag.setAccessible(true);

        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance = declaredConstructor.newInstance();

        flag.set(instance,false);

        LazyMan instance2 = declaredConstructor.newInstance();


        System.out.println(instance);
        System.out.println(instance2);
    }
}

/**
 * 1、分配内存空间
 * 2、执行构造方法，初始化对象
 * 3、把这个对象指向这个空间
 *
 * 123
 * 132 A
 *     B // 此时lazyMan还没有完成构造
 */

这里的双重检测枷锁是保证了操作原子性，只有一个线程能创建一个实例，其他线程无法创建第二个，volatile关键字是为了防止因为指令重排导致的多线程问题，有可能线程A创建一个实例，虚拟机只执行了分配空间，对象地址引用这两步，这时线程B过来发现对象已经被创建了，但是获取到的对象是还没有被初始化的。

16.3、静态内部类

package com.chen.single;

// 静态内部类
public class Holder {

    private Holder(){}

    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }

    public static class InnerClass{
        private static final Holder HOLDER = new Holder();
    }

}

16.4、枚举

单例不安全，因为有反射

package com.chen.single;

import com.sun.org.apache.regexp.internal.RE;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

// enum 是一个什么？ 本身也是一个Class类
public enum EnumSingle {

    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();

        // NoSuchMethodException: com.chen.single.EnumSingle.<init>()
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

枚举类型的最终反编译
学习视频链接：https://www.bilibili.com/video/BV1B7411L7tE?p=33