概念

单例模式的类必须保证只有一个实例对象。

特点

  • 单例类只有一个实例对象。
  • 该单例对象只能由该单例类自主创建。
  • 单例类为外部提供一个访问该单例的全局访问点。

应用场景

对于Java来说,单例模式可以保证在JVM中只存在一个实例,主要应用场景如下:

  • 需要频繁创建的类,使用单例可以降低系统内存的压力,减少GC。
  • 实例化时比较占用资源,创建时间长,且经常使用的时候。
  • 需要频繁使用,但是创建的对象又频繁的销毁的时候,例如多线程的连接池和网络池。
  • 频繁访问数据库或文件的对象。
  • 对于一些硬件级别的操作,或者从整个系统来说是单一控制逻辑的对象,如果是多例,那么系统将完全乱套。
  • 用于需要共享的场景。由于单例模式只有一个实例对象,共享该对象可以节省内存,并提高系统访问速度。如Web中的配置对象,数据库的连接池等。

实现方式

饿汉式

public class Singleton {

    private static final singleton = new Singleton();
    
    // 私有化构造方法,防止外部直接创建
    private Singleton(){};

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

饿汉式在类被初始化的时候就已经在内存中创建了对象,以空间换时间,不存在线程安全问题

懒汉式

双重检查锁

public class Singleton {
    
    private volatile static Singleton instance;

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

}

双重检查锁的优势是在调用方法的时候才创建对象,这样可以节省内存空间。同时这也是懒汉式的优点。而双重检查锁是为了保证在多线程环境下的线程安全问题。

双重检查锁是如何保证线程安全的?
在执行程序的过程中,为了提高性能,在不改变程序运行的结果且不存在数据依赖的关系的情况下,处理器和编译器常常会进行指令重排。
在JVM中,

instance = new Singleton();

这行代码分为三个步骤
1.为对象分配内存空间。
2.初始化对象。
3.将对象指向分配的内存空间。
但是,有些编译器为了性能的原因,会进行指令重排,先执行3,再执行2,顺序就变成了
1.为对象分配内存空间。
2.将对象指向分配的内存空间。
3.初始化对象。

TimeThred AThred A
T1检查到instance为null
T2获取锁
T3再次检查到instance为null
T4为对象分配内存空间
T5将对象指向分配的内存空间
T6 检测到instance不为空
T7 访问instance对象(但此时instance还未初始化)
T8初始化instance

在这种情况下,T7时刻线程B对uniqueSingleton的访问,访问的是⼀个初始化未完成的对象。

  • 为避免该情况,使用volatile修饰实例对象禁止指令重排序。

那为什么要进行两次判空呢?第一次还有必要吗?

  • 第一个判空是为了避免不必要的加锁,因为加锁是一个比较浪费性能的事,如果第一次不为空,说明对象已经创建了,那么直接返回对象。

静态内部类方式实现(Effective Java 推荐)

public class Singleton {

    // 私有化构造方法,防止外部直接创建
    private Singleton(){};

    public static Singleton getInstance() {
	return Holder.INSTANCE;
    }

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

静态内部类的优点是:外部类加载时并不需要立即加载内部类,内部类不被加载则不去初始化INSTANCE,故而不占内存。即当Singleton第一次被加载时,并不需要去加载Holder,只有当getInstance()方法第一次被调用时,才会去初始化INSTANCE,第一次调用getInstance()方法会导致虚拟机加载Holder类,这种方法不仅能确保线程安全,也能保证单例的唯一性,同时也延迟了单例的实例化。

那么静态内部类又是如何保证线程安全的呢?
首先,我们需要先了解下类的加载时机。
类加载时机:JAVA虚拟机在有且仅有的5种场景下会对类进行初始化。

  • 遇到new、getstatic、setstatic或者invokestatic这4个字节码指令时,对应的java代码场景为:new一个关键字或者一个实例化对象时、读取或设置一个静态字段时(final修饰、已在编译期把结果放入常量池的除外)、调用一个类的静态方法时。

  • 使用java.lang.reflect包的方法对类进行反射调用的时候,如果类没进行初始化,需要先调用其初始化方法进行初始化。

  • 当初始化一个类时,如果其父类还未进行初始化,会先触发其父类的初始化。

  • 当虚拟机启动时,用户需要指定一个要执行的主类(包含main()方法的类),虚拟机会先初始化这个类。

  • 当使用JDK 1.7等动态语言支持时,如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄,并且这个方法句柄所对应的类没有进行过初始化,则需要先触发其初始化。

  • 这5种情况被称为是类的主动引用,注意,这里《虚拟机规范》中使用的限定词是"有且仅有",那么,除此之外的所有引用类都不会对类进行初始化,称为被动引用。静态内部类就属于被动引用的行列。

我们再回头看下getInstance()方法,调用的是Holder.INSTANCE,取的是Holder 里的INSTANCE对象,跟上面那个双重检查锁机制不同的是,getInstance()方法并没有多次去new对象,故不管多少个线程去调用getInstance()方法,取的都是同一个INSTANCE对象,而不用去重新创建。

当getInstance()方法被调用时,SingleTonHoler才在SingleTon的运行时常量池里,把符号引用替换为直接引用,这时静态对象INSTANCE也真正被创建,然后再被getInstance()方法返回出去,这点同饿汉模式。那么INSTANCE在创建过程中又是如何保证线程安全的呢?在《深入理解JAVA虚拟机》中,有这么一句话:

虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步,如果多个线程同时去初始化一个类,那么只会有一个线程去执行这个类的()方法,其他线程都需要阻塞等待,直到活动线程执行()方法完毕。如果在一个类的()方法中有耗时很长的操作,就可能造成多个进程阻塞(需要注意的是,其他线程虽然会被阻塞,但如果执行()方法后,其他线程唤醒之后不会再次进入()方法。同一个加载器下,一个类型只会初始化一次。),在实际应用中,这种阻塞往往是很隐蔽的。

故而,可以看出INSTANCE在创建过程中是线程安全的,所以说静态内部类形式的单例可保证线程安全,也能保证单例的唯一性,同时也延迟了单例的实例化。

那么,是不是可以说静态内部类单例就是最完美的单例模式了呢?其实不然,静态内部类也有着一个致命的缺点,就是传参的问题,由于是静态内部类的形式去创建单例的,故外部无法传递参数进去,例如Context这种参数,所以,我们创建单例时,可以在静态内部类与双重检查锁模式里自己斟酌。

Q.E.D.


空有烟霞之志,叹无水云之身。