每日一问 | 类要先加载、链接、初始化才能实例化，有特殊Case吗？

上周公众号也有推过这个问题： https://mp.weixin.qq.com/s?__biz=MzAxMTI4MTkwNQ==&mid=2650835380&idx=2&sn=0acfb263d4a56987cc521bbfa4467518

文章说：如果在类里面声明一个类型为它自身的静态字段并实例化，像这样：

public class InitializationTest {

    final static InitializationTest INSTANCE = new InitializationTest();

    static {
        System.out.println(String.format("static initialization block invoked, instance = %s", INSTANCE));
    }

    {
        System.out.println(String.format("initialization block invoked, instance = %s", INSTANCE));
    }

    InitializationTest() {
        System.out.println(String.format("constructor invoked, instance = %s", INSTANCE));
    }

    public static void main(String[] a) {
        new InitializationTest();
    }
}

那么在运行时会看到initialization block和constructor先于static initialization block被执行：

initialization block invoked, instance = null
constructor invoked, instance = null

static initialization block invoked, instance = InitializationTest@2a139a55
initialization block invoked, instance = InitializationTest@2a139a55
constructor invoked, instance = InitializationTest@2a139a55

探究下为什么

先看看字节码：

这里把【实例化INSTANCE】和【打印static initialization block invoked】的指令都合并到一起了。

再转成java代码，实际等同于这样：

public class InitializationTest {

    final static InitializationTest INSTANCE;

    static {
        INSTANCE = new InitializationTest();
    }

    static {
        System.out.println(String.format("static initialization block invoked, instance = %s", INSTANCE));
    }

    ......
}

还有这样：

public class InitializationTest {

    final static InitializationTest INSTANCE;

    static {
        INSTANCE = new InitializationTest();
        System.out.println(String.format("static initialization block invoked, instance = %s", INSTANCE));
    }

    ......

}

可以看到INSTANCE的实例化是处于【静态初始化块】里面的，结合我们所学的Java基础：

一个类的【静态初始化块】只有在类被加载时才会执行且只有一次

像上面这种情况，如果在INSTANCE实例化之前还执行【静态初始化块】的话，岂不是一直递归下去了？

所以我猜测，JVM在即将执行【静态初始化块】之前，会有个FLAG记录当前状态，比如：是否已经初始化过、是否处于初始化中。只有在这两个状态都没有标记过的情况下，才会执行【静态初始化块】的代码。

把JDK源码（https://github.com/openjdk/jdk/）下载下来，印证一下这个猜想：

只是，源码那么庞大，应该怎么快速定位到具体文件呢？

不知道大家有没有了解过这个Error：ExceptionInInitializerError，如果在类的【静态初始化块】执行过程中发生没有捕获的异常，就会抛出这个错。

emmmm，我们可以尝试把它作为关键词搜一下，如果有的话，应该离【调用静态初始化块】的代码也不远了：

grep -rn "ExceptionInInitializerError" | grep /vm/ | grep ExceptionInInitializerError （因为我们要看JVM的代码，所以加了/vm/目录过滤）

咦？这个叫instanceKlass.cpp的文件，有点可疑，打开看下：

instanceKlass中，有ExceptionInInitializerError字眼的都集中在一个else里面，前面两处都是注释，第三处看样子是创建了java的ExceptionInInitializerError对象并抛出。

往上看：

原来是在一个叫initialize_impl的函数里面，咦？看这个函数第一行的注释：在初始化之前确保Class已经链接？！接着又调用了link_class函数。

那基本可以确定Class的初始化就是这里了，从头看一遍（注意看注释）：

void InstanceKlass::initialize_impl(instanceKlassHandle this_oop, TRAPS) {
  // 链接Class
  this_oop->link_class(CHECK);

  {
    // 初始化锁
    oop init_lock = this_oop->init_lock();
    ObjectLocker ol(init_lock, THREAD, init_lock != NULL);

    // 阻塞除当前线程外的所有线程
    Thread *self = THREAD;

    ////////////////////////////////////////////////////////////////////////////////
    // 如果目标Class正在初始化，就会一直阻塞在这里，等待唤醒
    ////////////////////////////////////////////////////////////////////////////////
    while(this_oop->is_being_initialized()) {
        wait = true;
      ol.waitUninterruptibly(CHECK);
    }

    // 重复检查是否已经初始化过（主要针对刚刚阻塞过的线程）
    if (this_oop->is_initialized()) {
      DTRACE_CLASSINIT_PROBE_WAIT(concurrent, InstanceKlass::cast(this_oop()), -1,wait);
      return;
    }

    // 错误状态，将会抛出NoClassDefFoundError（这里还能看到，如果内存不足导致加载Class失败的话，同样也是抛NoClassDefFoundError而不是OutOfMemoryError的）
    if (this_oop->is_in_error_state()) {
      const char* desc = "Could not initialize class ";
      ......
      if (NULL == message) {
        // Out of memory: can't create detailed error message
        THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), className);
      } else {
        jio_snprintf(message, msglen, "%s%s", desc, className);
        THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), message);
      }
    }
    ////////////////////////////////////////////////////////////////////////////////
    // 标记状态为状态初始化中！！！
    ////////////////////////////////////////////////////////////////////////////////
    this_oop->set_init_state(being_initialized);
    this_oop->set_init_thread(self);
  }

   ......

   // 已印证猜想，下面的不用看了。。。

}

！！！真的就是我们所想的那样，有个正在初始化的状态！

如果在【静态初始化块】中创建自身实例的话，因为Class还没初始化完毕，最终还是会走到这个函数里，但是在继续调用【静态初始化块】代码之前，检测到当前Class正在初始化中，所以本次就直接跳过了这个流程！

整理一下这句话：

在类的【静态初始化块】中创建自身实例，会看到构造方法的log先于【静态初始化块】的log打印，这是因为在JVM在初始化类时，会检查目标Class是否处于is_initialized（已经初始化）或being_initialized（正在初始化）状态，如果是的话，会直接忽略，因为要保证【静态初始化块】只执行一次。

emmmm，在开头公众号的文章里，还提到一个问题：

多线程进行类的初始化会出问题吗

文章说不会（因为是线程安全的），但实际上会有个安全隐患。。。。那就是。。。死锁！！！

从上面的JVM源码能看出来，当Class初始化时，同时间只能有一个线程通过，其他线程会一直等待，所以就给了死锁机会（当然了这是很极端的情况才会发生）。

可以写代码来测试下：

class A {
    static {
        System.out.println("A initializing......");
        try {
            Thread.sleep(100L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new B();
    }
}

class B {
    static {
        System.out.println("B initializing......");
        try {
            Thread.sleep(100L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new A();
    }
}

public class InitializationTest {

    public static void main(String[] a) throws Exception {
        new Thread() {
            @Override
            public void run() {
                new A();
            }
        }.start();
        new B();
        System.out.println("Done.");
    }
}

哈哈哈哈哈，编译运行以上代码会发现，"Done."永远不会打印，进程一直卡在那里。