饿汉式，一上来就创建

//饿汉式单例
public class Hungry {

    private Hungry(){

    }
    private final static Hungry HUNGRY= new Hungry();
    public static Hungry getInstance() {
        return HUNGRY;
    }
    //饿汉式可能浪费空间
}

懒汉式，用的才创建

直接这样写，在多线程并发时会有问题，可能导致不是单例的

public class LazyMan {

    private  LazyMan() {
        System.out.println(Thread.currentThread().getName() + "ok");
    }

    private static LazyMan lazyMan;

    public static LazyMan getInstance() {
        //懒汉式，用到才创建， 但是在多线程并发时有问题！
        if(lazyMan == null) {
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }

    //模拟多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                LazyMan.getInstance();
            }).start();

        }
    }
}

加双重检测锁，volatile 关键字，保证懒汉单例创建

为什么进行双重检测而不是直接在方法上加synchronized？

在方法上加synchronized可以保证单例创建对象，但是对象创建完了，每次都只能一个线程获取对象，显然不合理
第一个检测 lazyMan == null是为了判断对象是否实例化，如果以及实例化了，直接返回对象即可。只有未实例化时才进去竞争锁
第二个检测是因为可能有两个线程都进入资源竞争，第一个线程创建完对象，释放锁，第二个可能继续又创建一个出来违反单例规则

为什么加 volatile 关键字？

因为new 对象这个操作不是原子操作，分为三步：1.分配内存空间， 2.执行构造方法初始化对象， 3.把这个对象指向空间
而且这三步操作在底层可能会出现指令重排，导致执行顺序并不是123，可能是132。
这样可能会A线程先执行了3对象指向空间不为空了，还没执行2，然后线程B进来发现对象不为空直接返回还没初始化好的对象，出现错误
volatile 关键字有禁止指令重排的作用

public class LazyMan {

    private  LazyMan() {
        System.out.println(Thread.currentThread().getName() + "ok");
    }

    private volatile static LazyMan lazyMan;

    public static LazyMan getInstance() {
        //懒汉式，用到才创建， 但是在多线程并发时有问题！
        //双重检测锁
        if(lazyMan == null) {
            synchronized (LazyMan.class) {
                if(lazyMan == null) {
                    lazyMan = new LazyMan();
                    // new 不是一个原子操作， 1.分配内存空间， 2.执行构造方法初始化对象， 3.把这个对象指向空间
                    // 底层是这3步操作，且可能出现指令重排，我们期望123执行，实际可能132执行
                    // 如果线程A先执行了3， 把对象指向了空间，空间没值，线程B来的时候对象 != null了，导致出现错误， 所以对象得加 volatile 包含禁止指令重排序的含义
                }
            }
        }
        return lazyMan;
    }

    //模拟多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                LazyMan.getInstance();
            }).start();
        }
    }
}

内部类

内部类实现的单例是懒加载的，且线程安全
静态内部类只有在第一次使用的时候才会被加载，由JVM保证其线程安全性，确保该成员变量只能初始化一次

补充：静态属性和静态代码块都是在类加载的时候进行初始化和执行，两者优先级一样，按编码顺序初始化
非静态属性和非静态代码块在构造方法之前执行
静态变量、静态代码块、非静态变量、普通代码块执行完毕后执行构造方法
属性加载顺序回顾可以看文章最后一章

public class Holder {
    private Holder(){

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

用反射破坏单例及相应对抗方式

使用单例破坏构造器的私有性

    public static void main(String[] args) throws Exception {
        LazyMan instance1 = LazyMan.getInstance();
   		//通过反射拿到无参构造器
        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true); //破坏构造器私有
        LazyMan instance2 = constructor.newInstance();
        System.out.println(instance1 == instance2); //false
    }

防止反射的对抗，构造器方法：

    private  LazyMan() {
        synchronized (LazyMan.class) {
            if(lazyMan != null) {
                throw new RuntimeException("不要试图使用反射破坏单例");
            }
        }
    }

用反射先获取无参构造器，导致 if(lazyMan == null) 条件失效，还是一直可以创建对象

    public static void main(String[] args) throws Exception {
   		//通过反射拿到无参构造器
        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        LazyMan instance2 = constructor.newInstance();
        LazyMan instance3 = constructor.newInstance();
        System.out.println(instance2 == instance3); //false
    }

再次防止反射的对抗，创建一个静态变量作为标志位，构造器方法：

//创建一个谁都不知道的静态变量， 作为判断条件
    private static boolean lych4 = false;
    private  LazyMan() {
        synchronized (LazyMan.class) {
            if(!lych4) {
                lych4 = true;
            }else {
                throw new RuntimeException("不要试图使用反射破坏单例");
            }
        }
    }

假设用某种方法获取到了你标志位变量的名字，然后用反射获取到这个属性，破坏其私有，手动改变其值，破坏单例

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

        Field lych4 = LazyMan.class.getDeclaredField("lych4");
        lych4.setAccessible(true); //破坏属性的私有性

        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        LazyMan instance1 = constructor.newInstance();
        lych4.set(instance1, false); //设置lych4的值
        LazyMan instance2 = constructor.newInstance();

        System.out.println(instance1 == instance2);
    }

到底怎么办呢？

真正解决，实现防止被破坏的单例

先看反射的构造器 newInstance() 方法源码
在这里插入图片描述
可以发现如果类是一个枚举类（ENUM）的话，会抛出异常：“不能用反射创建枚举对象”

所有如果单例模式不想被反射破坏，终极武器就是使用枚举对象

测试：

创建枚举类

/**
 * enum 本身也是一个class类
 */
public enum  EnumSingle {

    INSTANCE;

    public  EnumSingle getInstance() {
        return INSTANCE;
    }
}

尝试反射破坏枚举类, 查看EnumSingle 的class文件发现里面有一个空参构造器，
尝试通过反射获取空参构造器去创建对象，：

    public static void main(String[] args) throws Exception {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1 == instance2);
    }

报错：Exception in thread “main” java.lang.NoSuchMethodException: cn.lych4.sigle.EnumSingle.()
报错说没有这个方法（构造器），而不是报的 “不能用反射创建枚举对象”。不太对劲，这说明枚举类里面没有空参构造器。class文件显示的Java代码不太对

经过专业软件，把class文件转为Java文件发现枚举类里面是有参构造

发现有参构造，那我们通过反射获取有参构造器，尝试用反射破坏单例：

    public static void main(String[] args) throws Exception {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1 == instance2);
    }

报错：Cannot reflectively create enum objects at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
成功报了：“不能用反射创建枚举对象”这个错误，说明确实不能用反射来破坏枚举类的单例。