单例模式

单例模式

1. 单例类只能有一个实例
2. 单例类必须自己创建自己的唯一实例
3. 单例类必须给所有其他对象提供这一实例

经典单例实现

public class Singleton {
    private static Singleton uniqueInstance = null;

    private Singleton() {}

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

上面的实现是最简单的单例模式，也称懒汉式单例实现，在单线程的时候这个写法并没有问题，在多线程的时候，由于没有同步，则会变成一个线程不安全的类，所以在并发环境下一般都会出现多个实例的情况。

Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。（事实上，通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。）。

使用反射访问私有构造方法

public class SingletonFactory {

    private static Singleton singleton;

    static
    {
        try {
            Class c = Class.forName(Singleton.class.getName());
            Constructor constructor = c.getDeclaredConstructor();
            constructor.setAccessible(true);
            singleton = (Singleton) constructor.newInstance();
        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    public static Singleton getSingleton() {
        return singleton;
    }
}

饿汉式单例实现

在类初始化时，已经自行实例化。

public class Singleton {
    private Singleton() {}
    // 自行实例化
    private static final Singleton single = new Singleton(); 

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

懒汉式单例实现（延迟加载）

在第一次调用的时候实例化。

上面已经说了最简单的饿汉式单例的实现，因为其是线程不安全的，所以我们可以考虑在方法上加锁，如下所示

public class Singleton {
    private static Singleton single = null;
    private Singleton() {}
    // 静态工厂方法
    public static synchronized Singleton getInstance() {
        if (single == null) {
            single = new Singleton();
        } 
        return single;
    }
}

上述方法虽然解决了线程不安全的问题，但是由于是对整个方法加锁，所以效率就受到了一定的影响，所以人们就研究出来了一种双重检查锁（DCL）的模式

public class Singleton {
    private Singleton() {}
    private static Singleton instance = null;
    // 静态工厂方法
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

如上述的代码可以看出，如果第一次检查instance不为null，那么就不需要执行下面的加锁和初始化操作，所以可以大幅降低synchronized带来的开销

但是这个方法却有着很致命的一个错误没有修正：当线程读取到instance不为null时，instance引用的对象有可能还没有完成初始化。

我们就这个问题可以把instance = new Singleton();这一句代码分解为下面的三个步骤：

1. 分配对象的内存空间：memory = allocate()
2. 初始化对象：ctorInstance(memory)
3. 设置instance指向刚分配的内存地址

问题就出现在上面的2和3步骤，因为在某些JIT编译器中，会把2和3进行重排序，所以当另外一条线程判断到instance不为null时，线程则直接访问instance所引用的对象，但此时这个对象可能还没有被初始化，重排序的情况如下

对于上面的问题我们可以使用volatile关键字和基于类的初始化来解决

// 基于volatile关键字
public class Singleton {
    private Singleton() {}
    private volatile static Singleton instance = null;
    // 静态工厂方法
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

// 基于类的初始化
public class InitializingOnDemandHolderIdiom {

    public static InitializingOnDemandHolderIdiom getInstance() {
        return HelperHolder.INSTANCE;
    }

    private static class HelperHolder {
        private final static InitializingOnDemandHolderIdiom INSTANCE = new InitializingOnDemandHolderIdiom();
    }
}  

使用枚举类型强化单例类

// 线程安全
public enum EnumIvoryTower {

    INSTANCE;

    @Override
    public String toString() {
        return getDeclaringClass().getCanonicalName() + "@" + hashCode();
    }
}

单例模式的优点

• 减少内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化的时候。
• 减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读写配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决（在Java EE中采用单例模式时需要注意JVM垃圾回收机制）。
• 避免对资源的多重占用。
• 单例模式可以在系统设置全局的访问点，优化和共享资源访问。

单例模式的缺点

• 单例模式一般没有接口，扩展很困难。
• 单例模式对测试是不利的。 在并行开发环境中，如果单例模式没有完成，是不能进行测试的，没有接口也不能使用mock的方式虚拟一个对象。
• 单例模式与单一职责原则有冲突。

单例模式的使用场景

• 要求生成唯一序列号的环境。
• 在整个项目中需要一个共享访问点或共享数据。
• 创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源。
• 需要定义大量的静态常量和静态方法（如工具类）的环境。

参考

1. Java并发编程的艺术
2. 设计模式
3. Effective Java