Har Java den initialiske fiasko for statisk rækkefølge?

Et nyt spørgsmål her havde følgende kode (godt, svarende til denne) til at implementere en singleton uden synkronisering.

public class Singleton {
    private Singleton() {}
    private static class SingletonHolder { 
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

Nu tror jeg, jeg forstår hvad dette gør. Da forekomsten er statisk endelig , er den bygget længe før nogen tråde kalder getInstance () , så der er ikke noget reelt behov for synkronisering.

Synkronisering er kun nødvendig, hvis to tråde forsøges at kalde getInstance () på samme tid (og denne metode byggede ved første opkald snarere end på "statisk endelig" tid).

Mit spørgsmål er derfor grundlæggende: hvorfor så ville du nogensinde foretrække doven konstruktion af singleton med noget som:

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

Mine eneste tanker var, at brug af statisk endelig metode kan introducere sekventeringsproblem som i C ++ statisk initialiseringsordens fiasko.

Første slukket, har Java faktisk dette problem? Jeg ved, at rækkefølge inden for en klasse er fuldt specificeret, men garanterer det på en eller anden måde ensartet rækkefølge mellem klasser (såsom med en klasselæsser)?

For det andet, hvis ordren er konsekvent, hvorfor ville den dovne konstruktionsmulighed nogensinde være fordelagtig?