从单例模式到类的初始化顺序

读完本文将了解到

• 单例模式的常用双重检查锁写法，以及如何避免JVM指令重排序导致的失效
• 更加高效、安全的内部静态类延时初始化的单例模式写法
• 类的初始化顺序（静态属性、静态代码块、普通属性、普通代码块、子类、父类...）

引子

我们都知道常见的单例模式的双重检查锁的形式，代码如下:

public class Singleton{
    private static volatile Singleton instance;                （4）
    private Singleton(){}                                     
    public static Singleton getInstance(){
        if(instance == null){                                   (1)
            synchronized(Singleton.class){                      (2)
                if(instance == null){                           (3)
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

其中通过(1)(3)作为双重检查,而(2)加锁保证初始化是线程安全的，
(4)中使用volatile关键字保证了内存可见性，防止指令重排序导致双重检查锁失效。

双重检查锁失效的原因是由于instance = new instance()不是原子性操作，从而留给了JVM重排序的机会。在单线程中，不管怎么排，最终结果都一致；在多线程情况下指令就会发生重排序出现问题。具体参考: 双重检查锁失效分析

更高效、安全的单例模式实现

在了解类初始化机制后可以采用更加高效、安全的线程安全单例模式，即内部静态类做延时初始化，代码如下：

public class Singleton{
    private static class SingletonHolder{
        private static final Singleton INSTANCE = new Singleton();（3）
    }
    private Singleton(){}
    public static Singleton getInstance(){                        （1）
        return SingletonHolder.INSTANCE;                          （2）
    }
}

其执行过程如下：
（1）执行Singleton.getInstance()，检测Singleton.class是否已被载入，若尚未被载入，则开始载入Singleton.class文件，并完成相应的静态初始化动作；
（2）执行SingletonHolder.INSTANCE，检测发现SingletonHolder.class尚未被载入，则开始载入SingletonHolder.class文件，并执行相应的静态初始化动作；
（3）SingleHolder.class中静态成员INSTANCE初始化动作会执行new Singleton()方法，完成了对Singleton实例INSTANCE的初始化操作后返回改实例。

类的初始化

类的初始化顺序 //todo 流程图完善

（1）类加载器检查该类的.class文件是否已被载入，若没有则载入；
（2）初始化静态属性、静态代码块（按代码顺序）；
（3）初始化普通属性、普通代码块（按代码顺序）；
（4）调用构造函数；
（5）在(1)、(2)、(3)、(4)的过程中若发现该类存在父类，并且其父类的.class尚未被载入如则先载入父类的.class文件，并执行父类的(2)、(3)、(4)、(5)步骤。

触发类初始化行为

（1）在使用new实例化对象，访问静态数据和方法时，也就是遇到指令：new，getstatic/putstatic和invokestatic时；
（2）使用反射对类进行调用时;
（3）当初始化一个类时，父类如果没有进行初始化，先触发父类的初始化；
（4）执行入口main方法所在的类；
（5）JDK1.7动态语言支持中方法句柄所在的类，如果没有初始化触发起初始化；

测试代码

class Parent{   
    private static String str1 = "父类静态属性1";   
    private String string = "父类普通属性";   
    static {      
        System.out.println(str1);  
        //error-illegal forward reference    
        System.out.println(str2);                                 (1)
        //ok-not accessed via a simple name
        System.out.println(Parent.str2);                          (2)
        System.out.println("父类静态代码块");   
    }   
    {      
        System.out.println(string);      
        System.out.println("父类普通代码块");   
    }   
    public static String str2 = "父类静态属性2";   
    public Parent() {      
        System.out.println("父类构造函数");   
    }
}
class Child extends Parent{   
    private static String str = "子类静态属性";   
    private String string = "子类普通属性";   
    static {      
        System.out.println(str);      
        System.out.println("子类静态代码块");   
    }   
    {      
        System.out.println(string);      
        System.out.println("子类普通代码块");   
    }   
    public Child() {      
        System.out.println("子类构造函数");   
    }
}
class Child2 extends Parent{   
    private static String str = "子类2静态属性";   
    private String string = "子类2普通属性";   
    static {      
        System.out.println(str);      
        System.out.println("子类2静态代码块");   
    }   
    {      
        System.out.println(string);      
        System.out.println("子类2普通代码块");   
    }   
    public Child() {      
        System.out.println("子类2构造函数");   
    }
}
public class MainTest {   
    static {      
        System.out.println("MainTest静态代码块");   
    }   
    public static void main(String[] args){    
        System.out.println("main() executed");  
        new Child();   
    }
}

输出结果

MainTest静态代码块
main() executed
父类静态属性1
null
父类静态代码块
子类静态属性
子类静态代码块
父类普通属性
父类普通代码块
父类构造函数
子类普通属性
子类普通代码块
子类构造函数
子类2静态属性
子类2静态代码块
父类普通属性
父类普通代码块
父类构造函数
子类2普通属性
子类2普通代码块
子类2构造函数

结果分析

结果与前面描述的类初始化顺序结论一致，有几点需要注意：
1、静态属性和静态代码块是按照统一的顺序执行的。
2、在代码(1)之所以编译器会报“illegal forward reference”是因为在声明str2之前就进行了read操作，要想强制使用，必须使用完成的类名+变量名。如果使用类名+变量名，这种向前引用就是null,如(2)所示。
3、更多详细参考illegal forward reference的介绍在The Java Language Specification的Forward References During Field Initialization

总结

1、传统的双重检查锁单例模式有时会由于在多线程情况下JVM的指令重排序导致失效的情况，要避免这种情况，需要给instance加上volatile关键字保证内存可见性，防止指令重排序。
2、为了更高效安全的实现单例模式，采用内部静态类做延时初始化方法，由JVM的类加载初始化机制帮我们实现线程安全的单例模式。
3、为了加深对类初始化顺序的理解，先介绍了类的初始化顺序伪代码，并在后文编写代码进行了结果验证和分析。