1、饿汉式（推荐使用）

类加载到内存后，就实例化一个单例，JVM保证线程安全

简单实用，推荐使用！

唯一缺点：不管用到与否，类装载时就实例化

（话说你不用的，你装载它干啥）

Class.forName(""); 只加载，不实例化

public class Mgr01 {
    private static final Mgr01 INSTANCE = new Mgr01();

    private Mgr01() {};

    public static Mgr01 getInstance() {
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        Mgr01 m1 = Mgr01.getInstance();
        Mgr01 m2 = Mgr01.getInstance();
        System.out.println(m1 == m2);
    }
}

2、饿汉式 - 使用静态代码块（同第一种）

public class Mgr02 {
    private static final Mgr02 INSTANCE;
    static {
        INSTANCE = new Mgr02();
    }

    private Mgr02() {};

    public static Mgr02 getInstance() {
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        Mgr02 m1 = Mgr02.getInstance();
        Mgr02 m2 = Mgr02.getInstance();
        System.out.println(m1 == m2);
    }
}

3、懒汉式 - 判断非空再创建 - 线程不安全

虽然达到了按需初始化的目的，但却带来了线程不安全的问题

public class Mgr03 {
    //不能加final 因为final必须初始化
    private static Mgr03 INSTANCE;

    private Mgr03() {
    }

    public static Mgr03 getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->
                System.out.println(Mgr03.getInstance().hashCode())
            ).start();
        }
    }
}

4、懒汉式 - lazy loading - 线程安全synchronized - 效率低

在static getInstance方法上加synchronized，给.class加锁

虽然达到了按需初始化的目的，但却带来了线程不安全的问题

可以通过synchronized解决，但也带来效率下降。

public class Mgr04 {
    private static Mgr04 INSTANCE;

    private Mgr04() {
    }

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

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr04.getInstance().hashCode());
            }).start();
        }
    }
}

5、懒汉式 - lazy loading - 线程不安全synchronized(){}

public class Mgr05 {
    private static Mgr05 INSTANCE;

    private Mgr05() {
    }

    public static Mgr05 getInstance() {
        if (INSTANCE == null) {
            //妄图通过减小同步代码块的方式提高效率，然后不可行
            synchronized (Mgr05.class) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new Mgr05();
            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            //java8 lambda写法  当一个接口只有一个方法时 可用
            new Thread(()->{
                System.out.println(Mgr05.getInstance().hashCode());
            }).start();
        }
    }
}

不是线程安全的，因为if和synchronized不是原子性操作，线程a进入了if，线程b也进入了if，结果线程b先抢到了这把锁先创建了对象并释放，然后线程a继续执行，然后又创建了一个对象。

6、懒汉式 - lazy loading - 线程安全 - 双检索DCL（没必要）

双重检查单例

第一次检查是否还需要？

能省事儿，大多数线程在第一次进来之后就不会往下执行了。

需要加上volatile，防止指令重排。申请内存 -> 初始化 -> 指向新的内存地址

public class Mgr06 {
    private static volatile Mgr06 INSTANCE; //JIT

    private Mgr06() {
    }

    public static Mgr06 getInstance() {
        if (INSTANCE == null) {
            //双重检查
            synchronized (Mgr06.class) {
                if(INSTANCE == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr06.getInstance().hashCode());
            }).start();
        }
    }
}

7、静态内部类（懒加载完美写法之一）

JVM保证单例

加载外部类时不会加载内部类，这样可以实现懒加载

public class Mgr07 {

    private Mgr07() {
    }
     
    //静态内部类 JVM保证单例
    private static class Mgr07Holder {
        private final static Mgr07 INSTANCE = new Mgr07();
    }
   
    //调用这个方法时，才会实例化Mgr07Holder
    public static Mgr07 getInstance() {
        return Mgr07Holder.INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr07.getInstance().hashCode());
            }).start();
        }
    }


}

8、枚举单例（懒加载完美写法之二）

不仅可以解决线程同步，还可以防止反序列化。（effective java）

public enum Mgr08 {

    INSTANCE;

    public void m() {}

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr08.INSTANCE.hashCode());
            }).start();
        }
    }

}

在单例中为什么要防止序列化反序列化？

java的反射可以通过class文件加载到内存，然后创建一个实例。

枚举类不会反序列化的原因是枚举类没有构造方法。