要知道，JVM只是一个标准，并不是实现。JVM中并没有规定有关编译器优化的内容，也就是说，JVM实现可以自由的进行编译器优化。

下面来想一下，创建一个变量需要哪些步骤呢？一个是申请一块内存，调用构造方法进行初始化操作，另一个是分配一个指针指向这块内存。这两个操作 谁在前谁在后呢？JVM规范并没有规定。那么就存在这么一种情况，JVM是先开辟出一块内存，然后把指针指向这块内存，最后调用构造方法进行初始化。

下面我们来考虑这么一种情况：线程A开始创建SingletonClass的实例，此时线程B调用了getInstance()方法，首先判断 instance是否为null。按照我们上面所说的内存模型，A已经把instance指向了那块内存，只是还没有调用构造方法，因此B检测到 instance不为null，于是直接把instance返回了——问题出现了，尽管instance不为null，但它并没有构造完成，就像一套房子 已经给了你钥匙，但你并不能住进去，因为里面还没有收拾。此时，如果B在A将instance构造完成之前就是用了这个实例，程序就会出现错误了！

于是，我们想到了下面的代码：

public class SingletonClass {

? private static SingletonClass instance = null;

? public static SingletonClass getInstance() {
? ? if (instance == null) {
? ? ? SingletonClass sc;
? ? ? synchronized (SingletonClass.class) {
? ? ? ? sc = instance;
? ? ? ? if (sc == null) {
? ? ? ? ? synchronized (SingletonClass.class) {
? ? ? ? ? ? if(sc == null) {
? ? ? ? ? ? ? sc = new SingletonClass();
? ? ? ? ? ? }
? ? ? ? ? }
? ? ? ? ? instance = sc;
? ? ? ? }
? ? ? }
? ? }
? ? return instance;
? }

? private SingletonClass() {

? }
? ?
}

我们在第一个同步块里面创建一个临时变量，然后使用这个临时变量进行对象的创建，并且在最后把instance指针临时变量的内存空间。写出这 种代码基于以下思想，即synchronized会起到一个代码屏蔽的作用，同步块里面的代码和外部的代码没有联系。因此，在外部的同步块里面对临时变量 sc进行操作并不影响instance，所以外部类在instance=sc;之前检测instance的时候，结果instance依然是null。

不过，这种想法完全是错误的！同步块的释放保证在此之前——也就是同步块里面——的操作必须完成，但是并不保证同步块之后的操作不能因编译器优化而调换到同步块结束之前进行。因此，编译器完全可以把instance=sc;这句移到内部同步块里面执行。这样，程序又是错误的了！

6. 解决方案

说了这么多，难道单例没有办法在Java中实现吗？其实不然！

在JDK 5之后，Java使用了新的内存模型。volatile关键字有了明确的语义——在JDK1.5之前，volatile是个关键字，但是并没有明确的规定 其用途——被volatile修饰的写变量不能和之前的读写代码调整，读变量不能和之后的读写代码调整！因此，只要我们简单的把instance加上 volatile关键字就??以了。

public class SingletonClass {

? private volatile static SingletonClass instance = null;

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

? private SingletonClass() {

? }
? ?
}

然而，这只是JDK1.5之后的Java的解决方案，那之前版本呢？其实，还有另外的一种解决方案，并不会受到Java版本的影响：

public class SingletonClass {
? ?
? private static class SingletonClassInstance {
? ? private static final SingletonClass instance = new SingletonClass();
? }

? public static SingletonClass getInstance() {
? ? return SingletonClassInstance.instance;
? }

? private SingletonClass() {

? }
? ?
}

在这一版本的单例模式实现代码中，我们使用了Java的静态内部类。这一技术是被JVM明确说明了的，因此不存在任何二义性。在这段代码中，因 为SingletonClass没有static的属性，因此并不会被初始化。直到调用getInstance()的时候，会首先加载 SingletonClassInstance类，这个类有一个static的SingletonClass实例，因此需要调用 SingletonClass的构造方法，然后getInstance()将把这个内部类的instance返回给使用者。由于这个instance是 static的，因此并不会构造多次。

由于SingletonClassInstance是私有静态内部类，所以不会被其他类知道，同样，static语义也要求不会有多个实例存 在。并且，JSL规范定义，类的构造必须是原子性的，非并发的，因此不需要加同步块。同样，由于这个构造是并发的，所以getInstance()也并不 需要加同步。

至此，我们完整的了解了单例模式在Java语言中的时候，提出了两种解决方案。个人偏向于第二种，并且Effiective Java也推荐的这种方式。