高频面试2：单例模式Singleton

什么是Singleton

Singleton就是单例设计模式，即某个类在整个系统中只能有一个实例对象被获取和使用。

例如：代表JVM运行时环境的Runtime类。

单例模式要满足的要求

• 1、某个类只能有一个实例，因此这个类的构造函数是私有的，不能暴露给外部，让外部随意new对象。
• 2、这个类必须能够自行创建唯一实例，并需要一个静态变量保存这个唯一实例。
• 3、这个类必须能向外部提供这个唯一实例，因此需要向外部暴露一个方法返回这个实例或直接public暴露这个实例给外部。

单例模式的两种实现方式

• 饿汉式：类加载并初始化的时候就生成了这个单例对象，因为一个类只会被加载并初始化一次，所以只会生成一次单例对象，不存在线程安全问题，但可能存在有时候不需要这个实例却进行了实例化的情况。
• 懒汉式：类加载并初始化的时候不生成对象，而是在调用类提供的某个方法时才new这个对象。因为一个方法可能被多个线程同时调用，因此懒汉式可能存在线程安全问题。

饿汉式的三种实现方式

• 1.直接创建对象-----最直观，最容易想到
  如果仅调用test()方法，并不需要使用instance ，但依然会造成其实例化

public class Singleton1 {
    private static Singleton1 instance = new Singleton1();
    private Singleton1() {

    }
    public Singleton1 getInstance() {
        return instance ;
    }
    public static void test() {  
    }
}

• 2.使用枚举-----最简洁
  使用只有一个对象的枚举。因为只有一个对象并且枚举的构造器默认是私有的，因此也是单例

public enum Singleton2 {
    INSTANCE
}

• 3.静态代码块创建对象-----适合复杂的场景

public class Singleton3 {
    private static Singleton3 instance;

    static {
        instance = new Singleton3();
        // ......其他需求
    }

    private Singleton3() {

    }
}

懒汉式的四种实现方式

• 1.线程不安全-----适合单线程
  如果两个线程在instance未实例化的时候调用getInstance，就可能导致线程安全问题。

public class Singleton4 {
    private static Singleton4 instance;

    private Singleton4() {

    }

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

• 2.线程安全-----适合多线程
  多线程情况下调用的时候，多个线程并不能同时得到对象，只能有一个线程拿到锁，其他线程阻塞，等拿到锁的线程获取到对象后，其他线程才能获取对象。

public class Singleton5 {
    private static Singleton5 instance;

    private Singleton5() {

    }

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

• 3.线程安全-----双重校验锁实现对象单例
  优点：解决了方法3中多线程获取对象导致线程阻塞的问题

class Singleton7 {
    private volatile static Singleton7 instance;

    private Singleton7() {

    }

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

instance = new Singleton7()这步具体的执行过程实际上包含了几个步骤，简化为如下：
1、为Singleton7对象分配内存
2、初始化Singleton7对象
3、将instance指向Singleton7对象
但是由于JVM具有指令重排的特性，执行顺序可能变为1->3->2，单线程情况下不会出现问题，但是多线程情况下会导致一个线程得到没有被初始化的对象。使用volatile可以禁止JVM指令的重排，保证在多线程情况下也能正常运行。

• 4.静态内部类-----线程安全，适合多线程
  外部类加载并初始化的时候并不会加载并初始化内部类，因此只有调用外部类的getInstance方法才会加载Inner类同时实例化instance。

public class Singleton6 {
    private Singleton6() {

    }
    private static class Inner{
        private static Singleton6 instance = new Singleton6();
    }
    public static Singleton6 getInstance() {
        return Inner.instance;
    }
}