单例模式
- 单例类只能有一个实例
- 单例类必须自己创建自己的唯一实例
- 单例类必须给所有其他对象提供这一实例
经典单例实现
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();
这一句代码分解为下面的三个步骤:
- 分配对象的内存空间:
memory = allocate()
- 初始化对象:
ctorInstance(memory)
- 设置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和数据库等资源。
- 需要定义大量的静态常量和静态方法(如工具类)的环境。
参考
- Java并发编程的艺术
- 设计模式
- Effective Java