【算法学习】剑指offer问题2——单例模式

Java语言实现单例模式的方法：

一、饿汉模式

public class Singleton {
    private static Singleton instance = new Singleton(); //类加载时即创建实例

    private Singleton() { // 初始化对象 }
 public static Singleton getInstance() { return instance; } }

优点：在类加载时创建实例，避免了多线程重复创建实例的情况。

缺点：类加载时即被创建实例，若实例没被使用，则浪费内存和时间。

场景：实例占用内存较小，初始化之后即被用到的场景。

二、懒汉模式

public class Singleton {
    private static Singleton instance = null;

    private Singleton() { // 初始化对象 }

    public static Singleton getInstance() {
        if(null == instance) { // 按需创建
            instance = new Singleton();
        }
        return instance;
    }

}

改进版本，解决多线程重复创建实例问题：

public class Singleton {
    private static Singleton instance = null;

    private Singleton() { // 初始化对象 }

    public static synchronized Singleton getInstance() { // 同步方法，只能有一个线程调用该方法
        if(null == instance) {
            instance = new Singleton();
        }
        return instance;
    }

}

优点：按需创建，线程安全。

缺点：性能差，统一时间只能有一个线程调用getInstance()方法。

场景：实例占用内存较大，使用次数较少的场景。

三、双重锁

public class Singleton {
    private static Singleton instance = null;

    private Singleton() { // 初始化对象 }

    public static Singleton getInstance() {
        if(null == instance) {
             synchronized (Singleton.class) {
                 if(null == instance) { // 双重校验锁，解决多线程并发时重复创建实例的情况
                     instance = new Singleton();
                 }
             }
        }
        return instance;
    }

}

优点：按需创建，线程安全，性能较同步方法好。

缺点：指令重排序仍然会导致多线程并发时状态不确定问题。具体原因：指令重排序导致对象初始化和将对象地址赋值给instance字段的顺序不确定。当一个线程调用getInstance()方法并创建实例，在调用构造方法之前，就为该对象分配了内存空间并将对象的字段设置为默认值。此时就可以将对象地址赋值给instance字段，然而对象尚未初始化（即构造方法中的逻辑）。若另一个线程此时调用getInstance()方法，则取到的是状态不确定的对象，程序可能出错。

改进，使用volatile关键字，禁止指令重排序，保证字段instance被赋值时，对象已经是初始化以后的：

public class Singleton {
    private static volatile Singleton instance = null; // 将instance声明为volatile类型

    private Singleton() {}

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

}

四、内嵌类

public class Singleton {
    private Singleton() {}

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }

    public static class SingletonHolder { // 静态内部类
        private static Singleton instance = new Singleton(); // 用类加载机制保证只创建一个实例
    }
}

优点：线程安全多线程并发只创建一个实例，延迟加载只要不使用内部类就不会加载。

五、枚举
以上四种方式的共同问题：
1、需要重写序列化：每次反序列化一个序列化的对象都会重新创建一个实例。
2、可以使用反射机制强制调用私有构造方法：解决该问题的方法，修改构造器，在创建第二个实例时抛出异常。

public enum Singleton {
    instance;
    public void anyMethod() {

    }
}

优点：枚举提供了线程安全和防止反射调用的构造器，提供序列化机制，防止反序列化时创建新的实例。

适用场景：《 Effective Java》中推荐使用该方法实现任何单例模式的需求，但很少有人使用。