在《并发编程实战》中建议用下面这个方法：延迟初始化占位类模式实现单例模式。
可以实现懒加载，也比双重检查加锁更好理解。

延迟初始化占位类

public class HolderSingleton  {
    
    
    private HolderSingleton() {
        
    }
    //这里调用内部类的时候加载内部类，因为是静态的，只能加载一遍。
    public HolderSingleton getInstance() {
        return Holder.instance;
    }
    //静态内部类和非静态内部类一样，只有在调用的时候才会别加载
    public static class Holder{
        private static HolderSingleton instance =new HolderSingleton();
        
    }

}

双重加锁

public class Singleton {
    private static volatile Singleton instance = null;

    private Singleton() {

    }

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

}

饿汉式

public class Singleton1 {
    private static final Singleton1 singleton1=new Singleton1();//饿汉形式，初始化时就进行初始化对象，并且声明不变性，可以保证线程安全。
    private Singleton1() {}
    public static Singleton1 getInstance() {
        return singleton1;
    }
}