一.

/**
 * @Name T00
 * @Description 懒汉模式（线程安全，无法懒加载）
 */
public class T00 {
    private final static T01 t01 = new T00();
    private T00(){
        //构造函数私有化，防止直接调用实例对象
    }
    public static T00 getInstace(){
        return t00;
    }
}

二.

/**
 * @Name T01
 * @Description 懒汉模式二（线程安全，无法懒加载，可以在static代码块加载一些方法或配置）
 */
public class T01 {
    private final static T01 t01;
    static {
        //do some thing
        t= new T01();
    }
    private T01(){
            //构造函数私有化，防止直接调用实例对象
    }
    public static T01 getInstace(){
        return T01.t01;
    }
}

三.

3-1.

/**
 * @Name T02
 * @Description 饿汉模式（线程不安全）
 */
public class T02 {
    private static T02 t02;
    private T02(){
        //构造函数私有化，防止直接调用实例对象
    }
    public static T02 getInstace(){
        if(t02 == null){
            t02 = new T02();
        }
        return t02;
    }
}

3-2.

/**
 * @Name T03
 * @Description 饿汉模式（线程安全，效率不高）
 */
public class T03 {
    private static T03 t03;
    private T03(){
            //构造函数私有化，防止直接调用实例对象
    }
    public synchronized static T03 getInstace(){
        if(t03 == null){
            t03 = new T03();
        }
        return t03;
    }
}

四.

4-1.

/**
 * @Name T04
 * @Description 饿汉模式（线程安全，效率比T03高,
 *  但jvm虚拟机重排序（jvm编译或运行时为提高代码执行效率会使代码重排序），可能会出现线程安全问题
 */
public class T04 {
    private static T04 t04;
    private T04(){
       //构造函数私有化，防止直接调用实例对象
    }
    public static T04 getInstace(){
        if(t04 == null){
            synchronized(T04.class){
                if(null == t04) {
                    t04 = new T04();
                }
            }
        }
        return t04;
    }
}

4-2.

/**
 * @Name T04_1
 * @Description 饿汉模式（线程安全，效率比T03高）
 * 加入 volatile 关键字，阻止jvm重排序，但影响效率
 *
 * 补充;1.volatile关键字作用：
 * 1.使（java内存模型）内存可见，
 * 2.阻止jvm虚拟机对代码重排序
 */
public class T04_1 {
    private volatile static T04_1 t04;
    private T04_1(){
        //构造函数私有化，防止直接调用实例对象
    }
    public static T04_1 getInstace(){
        if(t04 == null){
            synchronized(T04_1.class){
                if(null == t04) {
                    t04 = new T04_1();
                }
            }
        }
        return t04;
    }
}

五.

/**
 * @Name T05
 * @Description 内部类（线程安全，可以懒加载）
 */
public class T05 {
    private T05(){
        //构造函数私有化，防止直接调用实例对象
    }
    private static class Singleton{
            public static final T05 t05 = new T05();
    }
    public static T05 getInstace(){
        return Singleton.t05;
    }
}

六.

/**
 * @Name T06
 * @Description 内部枚举（线程安全，可以懒加载，从底层防止了反序列化破解的可能）
 */
public class T06 {
    private T06(){
        //构造函数私有化，防止直接调用实例对象
    }
    private enum Singleton{
        INSTANCE;
        private final T06 t06;
        Singleton(){
            t06 = new T06();
        }
    }
    public static T06 getInstace(){
        return Singleton.INSTANCE.t06;
    }
}