我们知道懒
汉式的实现
是延迟加载(Lazy Loading),但是不是
线程安全
的,
下面我们深入研究下为什么。
懒汉式的实现如下:
public
class
Singleton {
private static Singleton singleton;
private Singleton(){}
public static Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
相比于饿汉式实现,懒汉式是
线程安全的,因为懒汉式中的类成员
singleton
在声明时没有立即使用
new
关键字实例化,而是在
getInstance()
方法里面才使用
new
进行实例化,此时
Singleton
类的初始化不会实例化
singleton
。
只有当外部调用使用静态的
getInstance()
方法时,
类成员
singleton
才会被分配内存实例化,因此就达到了延迟加载的目的。
如有疑问,可参照
【单例深思】饿汉式与类加载
接下来我们重点来看看懒汉式为什么不是线程安全的?
在多线程情况下,如果
singleton
还没有被实例化,此时它的值为null,如果这时有可能多个线程同时进入
getInstance()
方法中,同时执行
if
(
singleton
==
null
)
这行代码,得到的结果都为true,于是这些线程都会使用
new
Singleton();
为
singleton
分配内存,这时
singleton
就不是单例了,所以
懒汉式
就不是线程安全的。
懒汉式改进版解决了这个问题,其实现如下:
public
class
Singleton {
private static Singleton instance;
private Singleton(){}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
其只改进了一个地方,就是使用关键字
synchronized
来声明
getInstance()
方法。这个关键字的作用就是给
getInstance()
加锁,加锁后这个方法就具备了原子性,每次只能由一个线程执行这个方法,其他请求线程则会被阻塞,直到活跃线程执行完毕。如果每次只有一个线程执行这个方法中的代码,那么我们上面讨论的线程安全问题就不复存在了,不会出现创建多个实例的情况了。
Java 提供了一种内置的锁机制来支持
原子性(
一组语句作为一个不可分割的单元被执行
):
同步代码块(Synchronized Block),同步代码块包括两部分,一个作为
锁的
对象引用,一个作为由这个锁保护的
代码块。以关键字
synchronized
来修饰的方法就是一种横跨整个方法体的同步代码块,其中该同步代码块的锁就是方法调用所在的对象。静态的
synchronized
方法以Class 对象作为锁。
synchronized(lock){
//由锁保护的代码块
}
每个Java对象都可以用做一个实现同步的锁,这些所被称为内置锁。
线程进入同步代码块之前会自动获得锁,并且在退出同步代码块时自动释放锁,而无论是通过正常的控制路径退出,还是通过从代码块中抛出异常退出。获得内置锁的唯一途径就是进入由这个锁保护的同步代码块或方法。
Java 的内置锁相当于一个互斥体(或互斥锁),这意味着最多只有一个线程能持有这种锁,当线程A尝试获取一个由线程B持有的锁时,线程A必须等待或阻塞,直到线程B释放这个锁。如果线程B永不释放这个锁,那么A就永远等待下去。
懒汉式改进版中
getInstance()
方法是静态的
synchronized
方法,因此以
Singleton.Class
作为锁,
线程只有获得了这个锁才能执行
getInstance()
方法,因此保证了线程安全性。但是这个锁只有一个,意味着同一时刻只能有一个线程执行该方法。如果这个单例很火,有很多线程需要获取它,那么就会影响单例的获取。这也是
synchronized
方法的一个弊端,代码的性能比较糟糕。这种简单且粗粒度的方法能确保线程安全性,但是不能同时处理多个请求,付出的代价很高。
这也就是双重检测锁实现出现的原因,通过缩小锁的粒度来增强活跃度,这将在下篇文章中详细讨论。