这样就规避了两个线程同时创建Singleton对象的风险,但是引来另外一个问题:每次去获取对象都需要先获取锁,并发性能非常地差,极端情况下,可能会出现卡顿现象。接下来要做的就是优化性能
:目标是如果没有实例化对象则加锁创建,如果已经实例化了,则不需要加锁,直接获取实例
所以直接在方法上加锁的方式就被废掉了,因为这种方式无论如何都需要先获取锁
public static Singleton getInstance() { if (singleton == null) { // 线程A和线程B同时看到singleton = null,如果不为null,则直接返回singleton synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化 if (singleton == null) { // 其中一个线程进入该分支,另外一个线程则不会进入该分支 singleton = new Singleton(); } } } return singleton; }
上面的代码已经完美地解决了并发安全 + 性能低效问题:
- 第 2 行代码,如果 singleton 不为空,则直接返回对象,不需要获取锁;而如果多个线程发现 singleton 为空,则进入分支;
- 第 3 行代码,多个线程尝试争抢同一个锁,只有一个线程争抢成功,第一个获取到锁的线程会再次判断singleton 是否为空,因为 singleton 有可能已经被之前的线程实例化
- 其它之后获取到锁的线程在执行到第 4 行校验代码,发现 singleton 已经不为空了,则不会再 new 一个对象,直接返回对象即可
- 之后所有进入该方法的线程都不会去获取锁,在第一次判断 singleton 对象时已经不为空了
因为需要两次判空,且对类对象加锁,该懒汉式写法也被称为:Double Check(双重校验) + Lock(加锁)
完整的代码如下所示:
public class Singleton { private static Singleton singleton; private Singleton(){} public static Singleton getInstance() { if (singleton == null) { // 线程A和线程B同时看到singleton = null,如果不为null,则直接返回singleton synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化 if (singleton == null) { // 其中一个线程进入该分支,另外一个线程则不会进入该分支 singleton = new Singleton(); } } } return singleton; } }
上面这段代码已经近似完美了,但是还存在最后一个问题:指令重排
使用 volatile 防止指令重排
创建一个对象,在 JVM 中会经过三步:
(1)为 singleton 分配内存空间
(2)初始化 singleton 对象
(3)将 singleton 指向分配好的内存空间
指令重排序是指:JVM 在保证最终结果正确的情况下,可以不按照程序编码的顺序执行语句,尽可能提高程序的性能
在这三步中,第 2、3 步有可能会发生指令重排现象,创建对象的顺序变为 1-3-2,会导致多个线程获取对象时,有可能线程 A 创建对象的过程中,执行了 1、3 步骤,线程 B 判断 singleton 已经不为空,获取到未初始化的singleton 对象,就会报 NPE 异常。文字较为晦涩,可以看流程图:
使用 volatile 关键字可以防止指令重排序,其原理较为复杂,这篇文章不打算展开,可以这样理解:使用 volatile 关键字修饰的变量,可以保证其指令执行的顺序与程序指明的顺序一致,不会发生顺序变换,这样在多线程环境下就不会发生 NPE 异常了。
volatile 还有第二个作用:使用 volatile 关键字修饰的变量,可以保证其内存可见性,即每一时刻线程读取到该变量的值都是内存中最新的那个值,线程每次操作该变量都需要先读取该变量。
最终的代码如下所示:
public class Singleton { private static volatile Singleton singleton; private Singleton(){} public static Singleton getInstance() { if (singleton == null) { // 线程A和线程B同时看到singleton = null,如果不为null,则直接返回singleton synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化 if (singleton == null) { // 其中一个线程进入该分支,另外一个线程则不会进入该分支 singleton = new Singleton(); } } } return singleton; } }
破坏懒汉式单例与饿汉式单例
无论是完美的懒汉式还是饿汉式,终究敌不过反射和序列化,它们俩都可以把单例对象破坏掉(产生多个对象)。
利用反射破坏单例模式
下面是一段使用反射破坏单例模式的例子
public static void main(String[] args) { // 获取类的显式构造器 Constructor<Singleton> construct = Singleton.class.getDeclaredConstructor(); // 可访问私有构造器 construct.setAccessible(true); // 利用反射构造新对象 Singleton obj1 = construct.newInstance(); // 通过正常方式获取单例对象 Singleton obj2 = Singleton.getInstance(); System.out.println(obj1 == obj2); // false }
上述的代码一针见血了:利用反射,强制访问类的私有构造器,去创建另一个对象
利用序列化与反序列化破坏单例模式
下面是一种使用序列化和反序列化破坏单例模式的例子
public static void main(String[] args) { // 创建输出流 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Singleton.file")); // 将单例对象写到文件中 oos.writeObject(Singleton.getInstance()); // 从文件中读取单例对象 File file = new File("Singleton.file"); ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file)); Singleton newInstance = (Singleton) ois.readObject(); // 判断是否是同一个对象 System.out.println(newInstance == Singleton.getInstance()); // false }
两个对象地址不相等的原因是:readObject() 方法读入对象时它必定会返回一个新的对象实例,必然指向新的内存地址。
让面试官鼓掌的枚举实现
我们已经掌握了懒汉式与饿汉式的常见写法了,通常情况下到这里已经足够了。但是,追求极致的我们,怎么能够止步于此,在《Effective Java》书中,给出了终极解决方法,话不多说,学完下面,真的不虚面试官考你了。
在 JDK 1.5 后,使用 Java 语言实现单例模式的方式又多了一种:枚举
枚举实现单例模式完整代码如下:
public enum Singleton { INSTANCE; public void doSomething() { System.out.println("这是枚举类型的单例模式!"); } }
使用枚举实现单例模式较其它两种实现方式的优势有 3 点,让我们来细品。