读完本文将了解到
- 单例模式的常用双重检查锁写法，以及如何避免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、为了加深对类初始化顺序的理解，先介绍了类的初始化顺序伪代码，并在后文编写代码进行了结果验证和分析。
