Lazy initialization的一个问题

上班路上看Effective Java的时候，看到Item48中有个不明之处。其中有段代码作者说是broken，但是我没有看出问题来，大家能否指点一下。

//The double-check idiom for lazy initialization -- broken

private static Foo foo = null;

public static Foo getFoo();{
    if(foo==null);{
        synchronized (Foo.class);{
            if(foo==null);
                foo=new Foo();;
        }
    }
    return foo;
}

作者说存在以下问题：
Unfortunately, the object reference is not guaranteed to work properly. If a thread reads the reference without synchronization and then invokes a method on the referenced object, the method may observe the object in a partially initialized state and fail catastrophically.

new 一个对象的时候，java没有做成一个原子操作，而是分成了两步：allocate memory, call constructor
所以并发的时候，这个例子会遇到返回一个未为初始化的对象的问题。

谢谢，还是有点疑惑，new Foo()的时候，代码不是已经synchronize Class了么。我的理解：如果Thread1正在new Foo()的时候，Thread2必须要等到Thread1创建完了才能getFoo()。是不是我对Class同步的理解错误了？

细化为两个小问题：
1.new Object()的过程；
2.Class同步的问题；
大家能给点文章链接么，不甚感谢：）

http://www.javaworld.com/javaworld/jw-02-2001/jw-0209-double.html

http://dev.csdn.net/article/24/24319.shtm

enjoy!

不深感谢，另有天地

顺便把看到的几个解决方法贴出：

// Works with acquire/release semantics for volatile
// Broken under current semantics for volatile
  class Foo {
        private volatile Helper helper = null;
        public Helper getHelper(); {
            if (helper == null); {
                synchronized(this); {
                    if (helper == null);
                        helper = new Helper();;
                }
            }
            return helper;
        }
    }

参考文章：
http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html