单例模式的深入理解

今天突然遇到一个问题，那就是如何深入的理解单例模式呢？包括其中需要考虑的线程安全，运行效率等。那我们直接看下面的代码吧：

public class Singleton {
    private static Singleton instance;
    private Singleton (){}
    public static Singleton getInstance() {
     if (instance == null) {
         instance = new Singleton();
     }
     return instance;
    }
}

上述这样的写法，我执行10个线程去执行，输出的结果如下：

第四条记录出现了意料之外的情况，那就是取出的对象不是同一个对象了，也就是说并不是单例，那么很快想到的解决办法就是将该方法设置为线程安全，代码如下：

public class ObjectInstance {
	private static  ObjectInstance instance;
	private ObjectInstance{}
	public synchronized  static  ObjectInstance getInstance() {
		if (instance == null) {
			   instance = new ObjectInstance();
		}
		return instance;
	}
}

显然上述的方式可以解决线程安全问题，毕竟synchronized是万能解决线程安全问题的关键词。但是新的问题来了，那就是synchronized会让整个吞吐量下降，如何解决呢？不妨看看下面的代码：

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

上述的代码没有将synchronized去除掉，而是将synchronized的范围缩小了，这里需要注意的是：在synchronized里也要再次判断非空性质。

这段代码看起来很完美，很可惜，它是有问题。主要在于instance = new Singleton()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。
1.给 instance 分配内存
2.调用 Singleton 的构造函数来初始化成员变量
3.将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）
但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。那么这个时候我们想到了关键词volatile ，因为volatile 可以做到以下几点：① 修饰的变量能够做到线程共享。② 可以防止指令重排 

public class Singleton {
    private volatile static Singleton instance; //声明成 volatile
    private Singleton (){}
    public static Singleton getSingleton() {
        if (instance == null) {                         
            synchronized (Singleton.class) {
                if (instance == null) {       
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }