单例bean与类加载过程

构造单例bean的方式有很多种，我们来看一下其中一种，饿汉式

public class Singleton1 implements Serializable {
    //1、构造函数私有
    private Singleton1() {
        if (INSTANCE != null) {
            throw new RuntimeException("单例对象不能重复创建");
        }
        System.out.println("private Singleton1()");
    }
//2、创建静态常量对象，Instance
    private static final Singleton1 INSTANCE = new Singleton1();
//3、使用getInstance（）获取对象
    public static Singleton1 getInstance() {
        return INSTANCE;
    }

    public static void otherMethod() {
        System.out.println("otherMethod()");
    }

    public Object readResolve() {
        return INSTANCE;
    }
}

其保证了单例bean的特性如下：

1、构造函数私有

2、创建静态常量对象，Instance

3、使用getInstance（）获取对象

并且对单例bean被破坏进行了防范：

• 构造方法抛出异常是防止反射破坏单例
• readResolve() 是防止反序列化破坏单例

目前来看，都没什么问题，但是如果我想创建两个静态变量 a与b呢，并且在new的时候对a，b进行++，会发生什么？

代码如下：

public class Singleton1 implements Serializable {
    //1、构造函数私有
    private Singleton1() {
        if (INSTANCE != null) {
            throw new RuntimeException("单例对象不能重复创建");
        }
        //调用构造函数时会对a与b进行++；
        a++;
        b++;
        System.out.println("private Singleton1()");
    }
    //2、创建静态常量对象，Instance
    private static final Singleton1 INSTANCE = new Singleton1();
    public static int a;
    public static int b=0;
    //3、使用getInstance（）获取对象
    public static Singleton1 getInstance() {

        return INSTANCE;
    }

    public static void otherMethod() {
        System.out.println("otherMethod()");
    }

    public Object readResolve() {
        return INSTANCE;
    }
}

这时如果我想对a与b进行输出，最终a、b的值会是多少？

public class TestCase {

    public static void main(String[] args) {
        Singleton1 instance = Singleton1.getInstance();
        System.out.println("a="+instance.a+"  b="+instance.b);

    }
}

想必很多人会认为答案是a与b各自+1；输出 a=1 b=1；

但是真相却是：

private Singleton1()
a=1  b=0

这时为什么呢？

这就与类加载机制有关了，首先我们得知道类加载过程，在类初始化之前，会有一个链接阶段，其中有一个步骤叫做准备

而在准备阶段将会：

1. 为类变量（static变量）分配内存并且设置该类变量的默认初始值，即零值
2. 这里不包含用final修饰的static，因为final在编译的时候就会分配好了默认值，准备阶段会显式初始化
3. 注意：这里不会为实例变量分配初始化，类变量会分配在方法区中，而实例变量是会随着对象一起分配到Java堆中

所以a与b在准备阶段被默认初始值为0；

接下来会进行类初始化，而类初始化的时机则有如下7种：

1. 创建类的实例
2. 访问某个类或接口的静态变量，或者对该静态变量赋值
3. 调用类的静态方法
4. 反射（比如：Class.forName(“com.atguigu.Test”)）
5. 初始化一个类的子类
6. Java虚拟机启动时被标明为启动类的类
7. JDK7开始提供的动态语言支持：java.lang.invoke.MethodHandle实例的解析结果REF_getStatic、REF putStatic、REF_invokeStatic句柄对应的类没有初始化，则初始化

很显然我们执行Singleton1 instance = Singleton1.getInstance();时，便对应上面第2点。所以会进行类初始化。

而在类初始化阶段也就是clinit():

1. 初始化阶段就是执行类构造器方法<clinit>()的过程

2. 此方法不需定义，是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并而来。也就是说，当我们代码中包含static变量的时候，就会有clinit方法

3. <clinit>()方法中的指令按语句在源文件中出现的顺序执行

4. <clinit>()不同于类的构造器。（关联：构造器是虚拟机视角下的<init>()）

5. 若该类具有父类，JVM会保证子类的<clinit>()执行前，父类的<clinit>()已经执行完毕

6. 虚拟机必须保证一个类的<clinit>()方法在多线程下被同步加锁

可以看到第3点，会跟据源文件种的出现顺序执行：

我们再看看最开始的代码中静态常量与变量的先后顺序：

  private static final Singleton1 INSTANCE = new Singleton1();
    public static int a;
    public static int b=0;

相比大家已经恍然大悟，对于答案也呼之欲出了。

没错，当在准备阶段，a，b将会被赋默认值为0，而当我们调用getInstance()时，就会触发类加载的过程，按照源码的先后顺序，先执行new Singleton1（），将会对a与b进行++，所以a与b分别为1。之后继续顺序执行，int a；不会改变a的值，而b=0，则重新将b从1覆盖为0了。所以最终我们显示a=1 b=0；

那么如何解决呢？

没错！只要修改一下变量声明的顺序，将a与b声明在INSTANCE之前，就不会出现a，b数据不一致的问题了！

谢谢大家阅读，才疏学浅，望多多指教！