双重检测锁的缺陷

双重检测锁实现的单例模式看起来非常完美，实则会出现同步问题。

public MyObject{
    private static MyObect instance;
    private Date d = new Data();
    public Data getD(){return this.d;}
    public static MyObect getInstance(){
        if(instance == null){
            synchronized(MyObect .class){ // 1
                if(instance == null) // 2
                    instance = new MyObject(); // 3
            }
        }
        return instance;
    }
}

1处会将线程进行同步。

2处会再次检查是否已经被其他线程实例化。

3处会出现JVM内存模型允许所谓的无序写入，如下

1: mem = allocate();        //Allocate memory for Singleton object.
2: instance = mem;          //Note that instance is now non-null, but
                         //has not been initialized.
3: ctorSingleton(instance); //Invoke constructor for Singleton passing

在2之后 instance 已经不为空。
若未执行3初始化，其他线程就已访问getD()，则d为空。
因为此时线程未离开synchronized块，所有instance所有的数据都未初始化且未同步。
这便是同步缺陷。

也可以使用贪婪方式，直接在类加载时初始化instance。

public MyObject{
    private static MyObect instance = new MyObject();
    private Date d = new Data();
    public Data getD(){return this.d;}
    public static getInstance(){
        return instance;
    }
}

Lazy-init的同步实现其实可以让jvm去实现。如下

public MyObject{

    private static class InstanceHoder{ //内部私有的类。
        static MyObject instance = new MyObject();
    }
    private Date d = new Data();
    public Data getD(){return this.d;}
    public static MyObect getInstance(){
           return InstanceHoder.instance;
    }
}

InstanceHoder内部类只有在使用到时候才会加载。