设计模式之单例模式二（解决无序写入的问题）

                在上篇文章中我们使用了双重检验锁的方式避免懒汉式单例模式下由于多线程造成的实例被多次创建的问题，但是因为由于JVM为了使得处理器内部的运算单元能充分利用，处理器可能会对输入代码进行乱序执行（Out Of Order Execute）优化，处理器会在计算之后将乱序执行的结果进行重组，保证该结果与顺序执行的结果是一样的，但并不保证程序中各个语句计算的先后顺序与输入的代码顺序一致。

              上篇文章的关于双重检验锁的代码是这样的：

 

public class Singleton{
	 
	 private static Singleton instance;
	 
	 //构造函数设置为私有使之不能被外界实例化
	 private Singleton(){ }
	 //获得实例
	 public  static Singleton getInstance(){
		if(instance==null){
			synchronized(Singleton.class){
				if(instance==null){
					instance=new Singleton()；
				}
			}
					 
		}
		 
		return instance;
	 }
	 
 }

 由于乱序执行的优化，导致在程序中执行的过程有时候并不是原子性的，在上面的代码中instance对象的创建就不是原子性的，可以说大部分对象的创建都不是原子性的。

 

        对象的创建的过程是这样的：

      1、给Singleton的实例分配内存空间。

      2、调用Singleton的构造方法进行构造函数初始化

      3、将instance对象指向分配的内存空间（注意到这步instance就非null了）

  对于上述创建过程不清楚的可以查看博客地址：http://blog.csdn.net/lingzhou1/article/details/8476709 。但是由JVM的乱序执行上面1、2、3的执行顺序2和3并不一定，可能是1、2、3也可能是1、3、2如果是1、2、3还好说并不会出现什么我问题，但是如是执行的顺序是1、3、2那么这样就比较麻烦了，因为在执行到3的时候对象已经是非null了，所以其线程有可能取到被初始化到一半的对象。

 

--------------------------------------------我是低调的分割线----------------------------------------------------

     说完了为什么双重检验锁因为乱序执行导致多线程下失效的问题，下面介绍一下如何解决这个我问题：

记得刘伟老师在讲课的时候说过使用volatile关键字修饰instance可以强制使之进行有序执行，but why？

volatile关键字到底是什么作用？再看《深入理解Java虚拟机》的时候我特地留意了一下这个问题，从Java内存模型的角度大概是这样说的：

     第一：保证被volatile修饰的变量会保证对所有的线程的可见性，这里的“可见性”是指当一条线程修改了这个变量的值，新值对于其他变量是可以立即i得知的。

   第二：使用volatile变量的语意是禁止指令重排序优化，普通的变量仅仅会保证该方法的执行过程中所有依赖赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操作顺序与程序代码中的执行顺序一致。

 

      所以我们可以使用volatile来阻止程序的乱序执行，从而使双重检验锁在多线程下正确执行。

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;
	 }
	 
 }

 但是我们在使用volatile的同时使我们的代码不能被编译器进行代码优化，他需要在本地代码中插入许多的内存屏障指令来保证处理器不发生乱序执行，导致我们的程序在执行的时候变慢。。。。。。。。。。。

好纠结。。。。到底什么才是最完美的呢？？？？？

 

      或许应该好好读一下下面这几行代码：

 

public class Singleton {    
    
    private static Singleton singleton; // 这类没有volatile关键字    
    
    private Singleton() {    
    }    
    
    public static Singleton getInstance() {    
        // 双重检查加锁    
        if (singleton == null) {    
            synchronized (Singleton.class) {    
                // 延迟实例化,需要时才创建    
                if (singleton == null) {    
                        
                    Singleton temp = null;  
                    try {  
                        temp = new Singleton();    
                    } catch (Exception e) {  
                    }  
                    if (temp != null)    
                        singleton = temp;
 //为什么要做这个看似无用的操作，因为这一步是为了让虚拟机执行到这一步的时会才对singleton赋值，虚拟机执行到这里的时候，必然已经完成类实例的初始化。所以这种写法的DCL是安全的。由于try的存在，虚拟机无法优化temp是否为null  
                }    
            }    
        }    
        return singleton;    
    }  
}  

 

 上面这种实现方法有没有比使用volatile快？我也不知道哈，希望大神出来给个答案撒。