五种单例模式实现

饿汉式：

public class Hunger {
public class Hunger {
    private Hunger() {
    }

    private final static Hunger hunger = new Hunger();

    public static Hunger getInstance() {
        return hunger;
    }
}

多个线程安全，但无法进行懒加载，如果类成员很多，则占用的资源比较多

懒汉式：

public class Lazy {
    private static Lazy lazy = null;

    private Lazy() {
    }

    public static Lazy getInstance() {
        if(lazy == null) {
            lazy = new Lazy();
        }
        return lazy;
    }
}

多线程下不安全，不能保证单例唯一

双重校验锁

public class DoubleCheck {
    /**
     * 禁止重排序，避免重排序导致的空指针异常
     */
    private volatile static DoubleCheck doubleCheck = null;

    private DoubleCheck() {
    }

    public static DoubleCheck getInstance() {
        if(doubleCheck == null) {
            synchronized (DoubleCheck.class) {
                if(doubleCheck == null) {
                    doubleCheck = new DoubleCheck();
                }
            }
        }
        return doubleCheck;
    }
}

静态内部类

public class StaticInnerClass {
    private StaticInnerClass() {
    }

    private static class InnerClass {
        private static StaticInnerClass staticInnerClass = new StaticInnerClass();
    }

    public static StaticInnerClass getStaticInnerClass() {
        return InnerClass.staticInnerClass;
    }
}

枚举

public enum  Enum {
    INSTANCE;
    
    public static Enum getInstance() {
        return INSTANCE;
    }
}

总结：

静态内部类和枚举是目前适用较广的单例设计