Java设计模式：单例模式的7种实现

全局只有一个实例对象：
1， 私有构造方法,
2， 提供一个访问实例好了对象的方法

这里只是列举了单例模式的几种写法（演进）

无并发问题，可以实际使用的有：
EHan、JingTaiNeiBuLei、LanHan4、MeiJu这4种；
其它三种LanHan模式存在并发或性能问题 。

代码结构

源码

package com.myspringboot.shejimoshi.danli;

/**
 * 饿汉式
 * 类加载到内存后，就实例化一个单例，JVM保证线程安全
 * 简单实用，推荐使用！
 * 唯一缺点：不管用到与否，类装载时就完成实例化(网上有看到说多类加载器时，会破坏【暂未想明白】
 */
public class EHan {
     
    private static final EHan INSTANCE = new EHan();

    private EHan() {
     };

    public static EHan getInstance() {
     
        return INSTANCE;
    }
}

package com.myspringboot.shejimoshi.danli;

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 */
public class LanHan1 {
     
    private static LanHan1 INSTANCE;

    private LanHan1() {
     
    }

    public static LanHan1 getInstance() {
     
        if (INSTANCE == null) {
     
            INSTANCE = new LanHan1();
        }
        return INSTANCE;
    }
}

package com.myspringboot.shejimoshi.danli;

/**
 * lazy loading
 * 也称懒汉式
 * 虽然可以通过synchronized解决线程不安全的问题，
 * 达到了按需初始化的目的，但也带来效率下降
 */
public class LanHan2 {
     
    private static LanHan2 INSTANCE;

    private LanHan2() {
     
    }

    public static synchronized LanHan2 getInstance() {
     
        if (INSTANCE == null) {
     
            INSTANCE = new LanHan2();
        }
        return INSTANCE;
    }
}

package com.myspringboot.shejimoshi.danli;

/**
 * lazy loading
 * 也称懒汉式
 * 试图通过减小同步代码块的方式提高效率，然而线程不安全的问题未解决
 */
public class LanHan3 {
     
    private static LanHan3 INSTANCE;

    private LanHan3() {
     
    }

    public static LanHan3 getInstance() {
     
        if (INSTANCE == null) {
     
            //妄图通过减小同步代码块的方式提高效率，然后不可行
            synchronized (LanHan3.class) {
     
                INSTANCE = new LanHan3();
            }
        }
        return INSTANCE;
    }
}

package com.myspringboot.shejimoshi.danli;

/**
 * lazy loading
 * 也称懒汉式
 * 经典双重检查+synchronized+volatile
 */
public class LanHan4 {
     
    private static volatile LanHan4 INSTANCE; //JIT

    private LanHan4() {
     
    }

    public static LanHan4 getInstance() {
     
        if (INSTANCE == null) {
     
            synchronized (LanHan4.class) {
     
                //双重检查
                if(INSTANCE == null) {
     
                    try {
     
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
     
                        e.printStackTrace();
                    }
                    INSTANCE = new LanHan4();
                }
            }
        }
        return INSTANCE;
    }
}

package com.myspringboot.shejimoshi.danli;

/**
 * 静态内部类方式
 * JVM保证单例
 * 加载外部类时不会加载内部类，这样可以实现懒加载
 */
public class JingTaiNeiBuLei {
     
    private JingTaiNeiBuLei() {
     
    }

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

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

package com.myspringboot.shejimoshi.danli;

/**
 * 不仅可以解决线程同步，还可以防止反序列化。
 */
public enum MeiJu {
     
    INSTANCE;
}