1、饿汉模式

public class HungrySingleton {

    private static final HungrySingleton instance = new HungrySingleton();

    private HungrySingleton(){}

    public static HungrySingleton getInstance(){
        return instance;
    }
}

饿汉模式在类加载的时候就完成了实例化，所以没有线程同步问题

2、懒汉模式

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

    //加private避免在外部被实例化
    private LazySingleton(){}

    public static LazySingleton getInstance(){
        if (instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }
}

适用于单线程，由于当线程1执行完 if (instance == null)后，还没开始new对象，线程2可能已经通过了这个判断并且已经实例化了对象，这时候就会产生多个对象

3、懒汉模式（加锁）

public class LazySingleton {

    //加上volatile关键字保证instance在所有线程中同步(操作可见性)
    private static volatile LazySingleton instance = null;

    //加private避免在外部被实例化
    private LazySingleton(){}

    //加synchronized同步
    public static synchronized LazySingleton getInstance(){
        if (instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }
}

适用于多线程。在原基础上加了双重锁（volatile和synchronized）可以保证在多线程环境下的安全问题