剑指offer面试题2：实现Singleton模式

实现单例模式应该是面试中比较常见的问题，下面简单讲讲几种单例模式的实现方式。

饿汉式

public class Singleton{
    public static Singleton instance = new Singleton();
    
    private Singleton();
    
    public static Singleton getInstance(){
        return instance;
    }
}

优点：避免线程同步产生的问题，没有加锁，效率更高。
缺点：在类加载的时候就初始化对象，浪费内存。

懒汉式

V1.0

public class Singleton{
    public static Singleton instance = null;
    
    private Singleton();
    
    public static Singleton getInstance(){
        if(instance == null){
            intance = new Singleton();
        }
        return instance;
    }
}

优点：需要时才创建对象，不会存在内存浪费。
缺点：多线程环境下不能正常工作，容易创建出多个对象。

V2.0

public class Singleton{
    public static Singleton instance = null;
    
    private Singleton();
    
    public static Singleton getInstance(){
        synchronized(this.class){
            if(instance == null){
                intance = new Singleton();
            }
        }
        return instance;
    }
}

优点：在方法加上synchronized关键字，保证了线程相对安全，不会创建出多个对象。
缺点：synchronized会导致效率低下。

V3.0 双重校验锁

public class Singleton{
    private static Singleton instance = null;
    
    private Singleton();

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

优点：既保证线程相对安全，又不会导致效率低下的问题。
缺点：
singleton = new Singleton()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。

1. 给 singleton 分配内存
2. 调用 Singleton 的构造函数来初始化成员变量，形成实例
3. 将singleton对象指向分配的内存空间（执行完这步 singleton才是非 null 了）
   但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。

对此，我们只需要把singleton声明成 volatile 就可以了。

V4.0

public class Singleton{
    private voletile static Singleton instance = null;
    
    private Singleton();

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

volatile有两个作用：

1. 这个变量不会在多线程中存在多个副本，直接从内存中读取
2. 防止指令重排序。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。

静态内部类

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

    public static getInstance(){
        return SingletonHandler.INSTANCE;    
    }
}

上面这种方式，仍然使用JVM本身机制保证了线程安全问题；由于 SingletonHolder 是私有的，除了 getInstance() 之外没有办法访问它。因此它只有在getInstance()被调用时才会真正创建；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖 JDK 版本。

枚举

public enum SingletonV6{
    INSTANCE;
}

默认枚举实例的创建是线程安全的，所以不需要担心线程安全的问题，而且因为JVM会阻止反射获取枚举类的私有构造方法，无法通过反射的方式构建对象。但是在枚举中的其他任何方法的线程安全由程序员自己负责。

总结

“陈式第一定理” : “无论你的代码写得有多好，其只能在特定的范围内工作，超出这个范围就要出Bug了”

如果我们的这个Singleton类是一个关于我们程序配置信息的类。我们需要它有序列化的功能，那么，当反序列化的时候，我们将无法控制别人不多次反序列化。

不过，我们可以利用一下Serializable接口的readResolve()方法，比如

class SingletonV7 implements Serializable {
    // ......
    // ......
    protected Object readResolve() {
        return getInstance();
    }

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

参考：

深入浅出单实例SINGLETON设计模式