1、饿汉式

private static final Mgr01 INSTANCE = new Mgr01();
             
    public static Mgr01 getInstance(){
        return INSTANCE;
    }

2、饿汉式 改

3、懒汉式 线程不安全

public class Mgr01 {
    private  static  Mgr01 INSTANCE ;
    private Mgr01(){
    }
    public  static Mgr01 getInstance(){
        if (getInstance()==null){
            INSTANCE = new Mgr01();
        }else {
            return INSTANCE;
        }
        return INSTANCE;
    }
}

4、懒汉式 加同步锁

private static volatile Mgr01 INSTANCE ;
public synchronized static Mgr01 getInstance(){
        if (INSTANCE==null){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr01();
        }else {
            return INSTANCE;
        }
        return INSTANCE;
    }

5、懒汉式 缩小同步锁

private static volatile Mgr01 INSTANCE ;
    private Mgr01(){
    }
    public  static Mgr01 getInstance(){
        if (INSTANCE==null){  //有实例后不在走锁
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (Mgr01.class) {
                if (INSTANCE == null) //确保只有一个实例
                    INSTANCE = new Mgr01();
            }
        }else {
            return INSTANCE;
        }
        return INSTANCE;
    }

6、内部类，最优写法

private Mgr01(){
    }
    public  static Mgr01 getInstance(){
        return Mgr01Holder.Instance;
    }
    private static class Mgr01Holder{
        private static final Mgr01 Instance = new Mgr01();
    }

7、枚举单例，最完美的

不但解决线程安全，还可以防止反序列化

public enum Mgr02 {
    INSTANCE;
}

单例要防止反序列化，因为一般可以通过反射，new Instance();–走的无参构造方法创建对象。枚举没有构造方法，所以防止了反序列化。
volatile，因为java语言JIT优化时，编译后指令重排，导致会返回没有初始化的对象。