单例模式的多种实现

单例模式的多种实现

饿汉式
类加载到内存后，就实例化一个单例，JVM保证线程安全
不管用到与否，类装载时就完成实例化
推荐使用

public class Mgr01 {
    private static final Mgr01 INSTANCE = new Mgr01();

    private Mgr01() {};

    public static Mgr01 getInstance() {
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        Mgr01 m1 = Mgr01.getInstance();
        Mgr01 m2 = Mgr01.getInstance();
        System.out.println(m1 == m2);
    }
}

懒汉式
虽然达到了按需初始化的目的，但却带来线程不安全的问题

public class Mgr03 {
    private static Mgr03 INSTANCE;

    private Mgr03() {
    }

    public static Mgr03 getInstance() {
        //这里不是虚拟唤醒，不能用weile解决.不明白为什么不是虚拟唤醒。
        if(INSTANCE == null) {
        //测试是否安全
            //try {
            //    TimeUnit.SECONDS.sleep(1);
            //} catch (InterruptedException e) {
            //    e.printStackTrace();
            //}
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr03.getInstance().hashCode());
            }).start();
        }
    }
}

3.双重锁结构
安全的懒汉式，效率略有下降
第一次if判断提高效率，第二次if判断线程安全

public class Mgr06 {
    private static volatile Mgr06 INSTANCE; //JIT

    private Mgr06() {
    }

    public static Mgr06 getInstance() {
        if (INSTANCE == null) {
            //双重检查
            synchronized (Mgr06.class) {
                if(INSTANCE == null) {
                   //测试是否安全
            //try {
            //    TimeUnit.SECONDS.sleep(1);
            //} catch (InterruptedException e) {
            //    e.printStackTrace();
            //}
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr06.getInstance().hashCode());
            }).start();
        }
    }
}

第一次判断，假设会有好多线程，如果没有被实例化，那么就会到下一步获取锁，只有一个能获取到锁，如果已经实例化，那么直接返回了，减少除了初始化时之外的所有锁获取的等待过程
加粗样式第二次判断是因为假设有两个线程A、B,两个同时通过了第一个if，然后A获取了锁，进入然后判断 Mgr06是null，他就实例化了Mgr06，然后他出了锁，这时候线程B经过等待A释放的锁，B获取锁了，如果没有第二个判断，那么他还是会去new Mgr06()，再创建一个实例，所以为了防止这种情况，需要第二次判断

4.静态内部类基本完美。jvm保证安全

public class Mgr07 {

    private Mgr07() {
    }

    private static class Mgr07Holder {
        private final static Mgr07 INSTANCE = new Mgr07();
    }

    public static Mgr07 getInstance() {
        return Mgr07Holder.INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr07.getInstance().hashCode());
            }).start();
        }
    }


}

大家可以告诉我，懒汉式哪里和虚拟唤醒的区别在那里吗。
双重锁结构参考：https://blog.csdn.net/qq_34203492/article/details/84324688