目录

1.饿汉式

2.饿汉式1.2

3.懒汉式

3.1懒汉式

3.2懒汉式

3.3懒汉式

4.静态内部类方式

5.枚举单例

1.饿汉式

•  类加载到内存后，就实例一个单例，JVM保证线程的安全
• 简单实用，推荐使用。
• 唯一缺点：不管用到与否，类装载时就完成实例化
•      （话说你不用的，不装他干嘛）

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.饿汉式1.2

•  和上面的01是一样的原理，只是在new的工作
• 放到下面进行写，静态代码块也是执行比较早的

  目录

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.懒汉式

• 懒汉式 虽然达到按需最初的效果，但却带来线程不安全的问题
• 我们知道懒汉式的单例模式，创建对象的时机在第一次调用getInstance（）方法。
• 而安全隐患就存在这时间段，倘若有两条线程都是运行该代码段，
• 一条线程运行过程进入了if语句块且
• 还没有把创建对象的实例赋值给成员变量时恰好进入了阻塞状态
• （还不清楚线程生命周期的小伙伴可理解为该线程暂停了）。
• 由于if语句判断条件依据是：instance == null才能进入该语句块
• 那么另一条线程就有可能会混进在该if语句块，
• 最后就会导致两个线程创建了两个不一样的对象。

public class Mgr03 {
    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++) {
            //同一个类的不同实例的hashCode是不一样的
            //如果不是同一个类的实例对象，hashCode有可能一样
            new Thread(()->
                System.out.println(Mgr03.getInstance().hashCode())
            ).start();
        }

//        Mgr03 m1 = Mgr03.getInstance();
//        Mgr03 m2 = Mgr03.getInstance();
//        System.out.println(m1 == m2);
    }
}

3.1懒汉式

• 懒汉式
• 虽然达到了按需初始化的需，但是出现了线程不安全的问题
• 可以通过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();
        }
    }
}

3.2懒汉式

• 懒汉式
• 虽然达到了按需初始化的需，但是出现了线程不安全的问题
• 可以通过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++) {
            new Thread(()->{
                System.out.println(Mgr05.getInstance().hashCode());
            }).start();
        }
    }
}

3.3懒汉式

• 虽然达到了按需初始化的需，但是出现了线程不安全的问题
• 可以通过synchronized进行处理，同时也带来问题 效率下降
• 通过采用双重验证的方法进行验证尝试提高效率 
• 但 无果

+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();
        }
    }
}

4.静态内部类方式

•  JVM保证单例
• 加载外部类时不会加载内部类，这样可以实现懒加载
• 静态内部类不会随着类的加载而进行加载，而是需要单独的加载和初始化

  private Mgr07() {
    }

    private static class Mgr07Holder {
        private final static Mgr07 INSTANCE = new Mgr07();
    }

    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();
        }
    }


}

5.枚举单例

• 不仅可以解决线程同步，还可以防止反序列化。

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();
        }
    }

}