懒汉单例
public class LazySingletonTest {
public static void main(String[] args) {
LazySingleton lazySingleton = LazySingleton.getInstance();
LazySingleton lazySingleton2 = LazySingleton.getInstance();
System.out.println(lazySingleton == lazySingleton2);
}
}
class LazySingleton {
private static LazySingleton instance;
private LazySingleton() {
}
public static LazySingleton getInstance() {
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
}
============================输出结果===========================
true
多线程情形
上面的程序使用单线程时不会有问题，但是使用多线程时会破坏单例。运行以下程序lazySingleton、lazySingleton2 不是同一个实例的情况。
public class LazySingletonTest {
public static void main(String[] args) {
new Thread(() -> {
LazySingleton lazySingleton = LazySingleton.getInstance();
System.out.println(lazySingleton);
}).start();
new Thread(() -> {
LazySingleton lazySingleton2 = LazySingleton.getInstance();
System.out.println(lazySingleton2);
}).start();
}
}
class LazySingleton {
private static LazySingleton instance;
private LazySingleton() {
}
public static LazySingleton getInstance() {
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
}
============================输出结果===========================
com.aircity.design.singleton.LazySingleton@2fd04fd1
com.aircity.design.singleton.LazySingleton@67c084e5
优化
为了解决上述的问题，只需要对 getInstance() 方法加锁即可，即：
public static synchronized LazySingleton getInstance() {
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
============================输出结果===========================
com.aircity.design.singleton.LazySingleton@1b9c704e
com.aircity.design.singleton.LazySingleton@1b9c704e
虽然解决了问题，但是 synchronized 的效率低下。因为每次执行 getInstance() 方法时都需要加锁，所以还需要细化锁的粒度，即只在 instance == null 时加锁。
public static LazySingleton getInstance() {
if (instance == null) {
synchronized (LazySingletonTest.class) {
instance = new LazySingleton();
}
}
return instance;
}
============================输出结果===========================
com.aircity.design.singleton.LazySingleton@2fd04fd1
com.aircity.design.singleton.LazySingleton@67c084e5
此时仍然会出现两个实例不为同一个的情况，是因为当前线程进入同步代码块时已经判断 instance 为 null，别的线程赋值后，当前线程并没有被通知到，继续优化。
public static LazySingleton getInstance() {
if (instance == null) {
synchronized (LazySingletonTest.class) {
if (instance == null) {
instance = new LazySingleton();
}
}
}
return instance;
}
============================输出结果===========================
com.aircity.design.singleton.LazySingleton@ae526cf
com.aircity.design.singleton.LazySingleton@ae526cf
在同步代码块内再加一重判空校验，防止因为别的线程赋值后，不被通知而破坏单例模式。到此为止，代码层面的懒汉单例模式已经完成。
字节码层面
代码层懒汉单例模式已经完毕，此时我们还要额外考虑字节码层会发生什么。instance = new LazySingleton(); 语句在编译期层面正常的执行顺序是：
- 分配空间： 先给
instance分配一块内存空间 - 空间初始化： 给分配到的内存空间进行初始化赋值，如：
int类型的初始值为0 - 引用赋值： 将
instance引用指向分配到内存空间地址
但是，在编辑器、CPU可能会发生指令重新排序，导致执行顺序改变：
- 分配空间
- 引用赋值
- 空间初始化
如果是多线程的话，可能线程A按照指令重新排序后执行到第3步时，线程B进入同步代码块发现对象已经引用赋值，就直接返回了 instance，但此时 instance 所指向的空间还没有初始化，就会发生异常。针对此情况，我们要做的就是防止指令重排，即使用 volatile 关键字修饰 instance。最终代码如下：
public class LazySingletonTest {
public static void main(String[] args) {
new Thread(() -> {
LazySingleton lazySingleton = LazySingleton.getInstance();
System.out.println(lazySingleton);
}).start();
new Thread(() -> {
LazySingleton lazySingleton2 = LazySingleton.getInstance();
System.out.println(lazySingleton2);
}).start();
}
}
class LazySingleton {
private volatile static LazySingleton instance;
private LazySingleton() {
}
public static LazySingleton getInstance() {
if (instance == null) {
synchronized (LazySingletonTest.class) {
if (instance == null) {
instance = new LazySingleton();
}
}
}
return instance;
}
}
