java double check

"double check"（双重检查锁定）是实现单例模式时常用的一种线程安全优化技术。最初，在一些旧版JVM实现中，单纯使用double check可能会导致线程安全问题，这是因为编译器和处理器的优化措施可能会导致指令重排序，使得单例对象没有完全初始化就被其他线程看见。

传统的double check单例模式大致如下：

```java
public class Singleton {
    private volatile static Singleton instance;
    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton(); // 这里可能出现问题
                }
            }
        }
        return instance;
    }
}
```

问题出在 `instance = new Singleton();` 这一行，它实际上是三个步骤的复合操作：
1. 分配内存空间
2. 初始化对象
3. 将instance引用指向新分配的内存地址

在多线程环境下，由于指令重排序的影响，步骤2和步骤3可能被打乱顺序，导致其他线程在初始化完成前就看到了非空但未初始化完成的instance对象。

为了解决这个问题，从Java 1.5开始引入了`volatile`关键字来修饰instance变量，以确保对其的读写操作具有原子性和可见性，禁止了指令重排序，从而解决了double check在旧版JVM中的线程安全问题。使用volatile修饰符后的double check单例模式在Java 1.5及以后版本的JVM中是线程安全的。

```java
private volatile static Singleton instance; // 注意添加了volatile关键字
``` 

因此，在正确使用volatile的情况下，double check单例模式是线程安全的。

扩展一下~~

关于double check单例模式的优化措施，上面的回答中提到了使用`volatile`关键字来确保实例变量的可见性和禁止指令重排序，这是对double check单例模式的一种优化。除此之外，针对Java 1.5及更高版本，还可以考虑使用`Enum`方式实现单例(消耗内存)，这种方式既简单又天然地具备线程安全性，不需要担心double check的问题。

然而，如果我们依然坚持使用double check模式，并考虑到JDK 1.5之后的并发API，可以进一步优化为使用`AtomicReference`或`懒汉Lazy Initialization Holder Class Pattern`：

1. 使用`AtomicReference`：

```java
import java.util.concurrent.atomic.AtomicReference;

public class Singleton {
    private static AtomicReference<Singleton> INSTANCE = new AtomicReference<>();

    private Singleton() {}

    public static Singleton getInstance() {
        Singleton result = INSTANCE.get();
        if (result == null) {
            synchronized (INSTANCE) {
                if (INSTANCE.get() == null) {
                    INSTANCE.set(new Singleton());
                    result = INSTANCE.get();
                }
            }
        }
        return result;
    }
}
```

2. 使用`Lazy Initialization Holder Class Pattern`（懒汉式加载持有类模式）：

```java
public class Singleton {
    private Singleton() {}

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

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

这种方式利用了类加载机制来保证线程安全，当第一次调用`getInstance()`方法时才会加载`SingletonHolder`类，从而初始化`Singleton`实例，而且仅初始化一次。这个方法既简单又高效，无需显式地使用`synchronized`关键字或`volatile`关键字，也不需要额外的并发API支持。