单例模式

单例模式(Singleton)，保证一个类仅有一个实例，并提供一个访问它的全局访问点。

单例模式结构图

单例的 6 种写法

(1) 饿汉模式

public class Singleton {

    private static Singleton instance = new Singleton();

    private Singleton() {

    }

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

这种方式在类加载时就完成初始化，所以类加载较慢，但获取对象的速度快。这种方式基于类加载机制，避免了多线程的同步问题。在类加载的时候就完成实例化，没有达到懒加载的效果。如果至始至终都未使用过这个实例，则会造成内存的浪费。

(2) 懒汉模式(线程不安全)

public class Singleton {

    private static Singleton instance;

    private Singleton() {

    }

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

懒汉模式声明了一个静态对象，在用户第一次调用时初始化。虽然节约了资源，但第一次加载时需要实例化，反应稍慢一些，而且在多线程时不能正常工作。

(3) 懒汉模式(线程安全)

public class Singleton {

    private static Singleton instance;

    private Singleton() {

    }

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

这种写法能够在多线程中很好地工作，但是每次调用 getInstance 方法时都需要进行同步。这会造成不必要的同步开销。不建议使用这种模式。

(4) 双重检查模式(DCL)

public class Singleton {

    private volatile static Singleton instance;

    private Singleton() {

    }

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

第一次判空是为了不必要的同步，第二次是在 Singleton 等于 null 的情况下才创建实例。当一个共享变量被 volatile 修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。这里使用 volatile 会或多或少影响性能，但考虑到程序的正确性，牺牲这点性能还是值得的。DCL 的优点是资源利用率高。第一次执行 getInstance 时单例对象才被实例化，效率高。缺点是第一次加载时反应稍慢一些，在高并发的情况下也有一定的缺陷。DCL 虽然在一定程度上解决了资源的消耗和多余的同步、线程安全等问题，但其还是在某些情况会出现失效的问题，也就是 DCL 失效。这里建议用静态内部类单例模式来替代 DCL。

(5) 静态内部类单例模式

public class Singleton {

    private Singleton() {

    }

    public static synchronized Singleton getInstance() {
        return SingletonHolder.sInstace;
    }
    
    private static class SingletonHolder {
        private static final Singleton sInstace = new Singleton();
    }
}

第一次加载 Singleton 类时并不会初始化 sInstace，但是第一次调用 getInstance 方法时虚拟机加载 SingletonHolder 并初始化 sInstace。这样不仅能保证线程安全，也能保证 Singleton 类的唯一性。所以推荐使用静态内部类单例模式。

(6) 枚举单例

public enum Singleton {
   INSTANCE;
   
   public void doSomeThing() {
   }
}

默认枚举实例的创建是线程安全的，并且在任何情况下都是单例。枚举单例的优点就是简单，但是大部分应用开发很少用枚举，其可读性不是很高。

反序列化问题

上述的 6 种单例模式实现中，有一种情况下其会重新创建对象，就是反序列化：将一个单例实例对象写到磁盘再读回来，从而获得了一个实例。反序列化操作提供了readResolve 方法，这个方法可以让开发者控制对象的反序列化。上诉几个方法实例中，如果要杜绝对象被反序列化时重新生成对象，就必须加入如下方法。

    private Object readResolve() throws ObjectStreamException{
        return instance;
    }

双重检查模式杜绝被反序列化代码

public class Singleton implements Serializable {

    private volatile static Singleton instance;

    private Singleton() {

    }

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

    private Object readResolve() throws ObjectStreamException{
        return instance;
    }
}

单例模式的使用场景

在一个系统中，要求一个类仅有一个对象，具体使用场景如下：

• 整个项目需要一个共享访问点或共享数据。
• 创建一个对象需要消耗的资源过多，比如访问 I/O 或者数据库等资源。
• 工具类对象。