具有内部类的 Java Singleton - 什么保证线程安全？

Question

实现单例的一种常见(1、2)方法是使用带有静态成员的内部类:

public class Singleton  {    
    private static class SingletonHolder {    
        public static final Singleton instance = new Singleton();
    }    

    public static Singleton getInstance() {    
        return SingletonHolder.instance;    
    }

    private Singleton() {
        //...
    }
}

据说这个实现是延迟初始化和线程安全的。但是到底是什么保证了它的线程安全呢？ JLS 17处理线程和锁 的文章没有提到静态字段具有任何类型的happens-before 关系。我如何确定初始化只会发生一次并且所有线程都看到相同的实例？

Answer 1

它在 Java Concurrency in Practice 中有详细描述:

The lazy initialization holder class idiom uses a class whose only purpose is to initialize the Resource. The JVM defers initializing the ResourceHolder class until it is actually used [JLS 12.4.1], and because the Resource is initialized with a static initializer, no additional synchronization is needed. The first call to getresource by any thread causes ResourceHolder to be loaded and initialized, at which time the initialization of the Resource happens through the static initializer.

静态初始化

Static initializers are run by the JVM at class initialization time, after class loading but before the class is used by any thread. Because the JVM acquires a lock during initialization [JLS 12.4.2] and this lock is acquired by each thread at least once to ensure that the class has been loaded, memory writes made during static initialization are automatically visible to all threads. Thus statically initialized objects require no explicit synchronization either during construction or when being referenced.