单例模式的坑

先看一段代码

/**
 * @author xiaofei.wxf
 */
public class SingletonA {
    private SingletonA(){}

    static final SingletonB b = SingletonB.b;
    static final SingletonA a = new SingletonA();
}

/**
 * @author xiaofei.wxf
 */
public class SingletonB {
    private SingletonB(){}

    static final SingletonA a = SingletonA.a;
    static final SingletonB b = new SingletonB();
}

/**
 * @author xiaofei.wxf
 */
public class Singleton {
    public static void main(String[] args) {
        SingletonA a = SingletonA.a;
        SingletonB b = SingletonB.b;

        SingletonA a1 = SingletonB.b.a;
        SingletonB b1 = SingletonA.a.b;

        System.out.println(a == a1);
        System.out.println(b == b1);
    }
}

输出是什么？

false
true

你的答案也是这个吗，或许你是对的，但也许你是蒙的。好，让我们来分析下其中的坑。

平时我们写单例的时候，一般不会注意细节，以为只要是static字段，jvm总会帮我们安排好一切。但是这里不然，Why？

对于static字段，jvm加载类之后会调用类的<clinit>方法，这个方法我们是看不到的，是java编译器为我们添加的。它的作用正如名字所表示的那样，class init，用来初始化所加载的类。clinit方法会按照我们定义的顺序，一个个初始化static的代码块或者字段。

那让我们看下上面的代码执行的流程：

1. 加载SingletonA类

2. 执行SingletonA 的 static final SingletonB b = SingletonB.b;

3. 加载SingletonB类

4. 执行SingletonB 的 static final SingletonA a = SingletonA.a;

到这一步SingletonB.a已经出来了，为null

5. 执行SingletonB 的 static final SingletonB b = new SingletonB();

这一步SingletonA.b 和 SingletonB.b  为 第一步创建的对象

6. 执行SingletonA 的 static final SingletonA a = new SingletonA();

这一步SingletonA.a 为第六步创建的对象

最后，SingletonA.a != SingletonB.a （null）

知道了原理，我们来把程序改正确

/**
 * @author xiaofei.wxf
 */
public class SingletonA {
    private SingletonA(){}
    static final SingletonA a = new SingletonA();

    static final SingletonB b = SingletonB.b;
}

/**
 * @author xiaofei.wxf
 */
public class SingletonB {
    private SingletonB(){}
    static final SingletonB b = new SingletonB();

    static final SingletonA a = SingletonA.a;
}

好了，调下次序就好了。这个简单的坑告诉我们，static的顺序很重要，我们写代码的时候要避免循环引用的问题，最好把单例的初始化放到第一行static中去。

你以为这样就结束了？继续看

既然是单例了，我们对其他类的引用就没必要是static的，对吧？

好的，我们去掉其他字段的static修饰符

/**
 * @author xiaofei.wxf
 */
public class SingletonA {
    private SingletonA(){}
    static final SingletonA a = new SingletonA();

    final SingletonB b = SingletonB.b;
}

/**
 * @author xiaofei.wxf
 */
public class SingletonB {
    private SingletonB(){}
    static final SingletonB b = new SingletonB();

    final SingletonA a = SingletonA.a;
}

还是调用之前的main方法，输出结果是什么？

false
true

没错，又出错了。

按照上面的方法我们再分析下

1. 加载A类

2. 执行A的clinit，执行A的static块，这时需要创建A对象

3. 调用A的构造器init方法，此时需要用到类B

4. 加载B类

5. 执行B的clinit，执行B的static块，这事创建B的对象

6. 执行B的构造器init方法，给B.a赋值为这时的A.a（null)

7. 回到A的构造函数init方法将B.b复制给A.b

8. 将A实例赋值给A.a 

所以a1值为null

这个程序是一个典型的循环应用初始化顺序问题，这也就是为什么Spring的IOC需要有个init方法的原因（个人认为）。

本例的场景如果不改变设计思路是无法解决这个问题的。解决方法两种，1. 学Spring给类价格init，但是Spring是容器调用init，但这里，谁也不想使用前调用下init 2. 静态块

必须要改变设计思路，使用静态块来解决，方法如下：

/**
 * @author xiaofei.wxf
 */
public class SingletonA {
    private SingletonA(){}
    static final SingletonA a = new SingletonA();
    static {
        a.b  = SingletonB.b;
    }
    SingletonB b;
}

/**
 * @author xiaofei.wxf
 */
public class SingletonB {
    private SingletonB(){}
    static final SingletonB b = new SingletonB();
    static{
        b.a = SingletonA.a;
    }
    SingletonA a;
}

结论：不起眼的地方总会导致我们程序运行出问题。并不是我们不知道这个知识点，拆解分析下来我们也是知道原因的，就是当程序太复杂的时候很难定位的具体的问题点。

所以，写程序给自己多几条原则，根据原则写就不太会掉进已知的坑里面。