06.JVM的类加载机制（初始化阶段）

上一篇：05.JVM的类加载机制（连接阶段：验证、准备、解析）

4.4类的初始化

• 通过准备阶段类变量已经赋过一次系统要求的初始零值，而初始化阶段就是在给类变量进行赋值操作。

• 初始化阶段会执行类构造器方法 < clinit > () ，该方法不同于类的构造器（是虚拟机视角下的< init >()）;

  该方法不需要定义，是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并而来。

• 通过代码观察：

  我们second类中的静态变量b是在 < clinit >方法中才被真正初始化的–>对应了静态变量的赋值操作
  
  如果我们在second类中再添加一个静态代码块，去修改b的值为11，这会验证静态代码块的操作也是在< clinit >中执行的：
  

• 注意1:

  编译器收集的顺序是由语句在源文件中出现的顺序决定的，静态语句块中只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块可以赋值，但是不能访问

  public class InitDemo {
      static {
          i = 20;// 给变量赋值可以正常编译通过
          //System.out.println(i);// 这句编译器会提示“非法向前引用”
      }
      public static int i = 10;
  }
  

  注意2：

  父类初始化先执行

  < clinit >()方法与类的构造函数（即在虚拟机视角中的实例构造器< init >()方法）不同，它不需要显

  式地调用父类构造器，Java虚拟机会保证在子类的< clinit >()方法执行前，父类的< clinit >()方法已经执行

  完毕。因此在Java虚拟机中第一个被执行的< clinit >()方法的类型肯定是java.lang.Object。

  注意3：

  线程同步

  Java虚拟机必须保证一个类的< clinit >()方法在多线程环境中被正确地加锁同步，如果多个线程同

  时去初始化一个类，那么只会有其中一个线程去执行这个类的< clinit >()方法，其他线程都需要阻塞等

  待，直到活动线程执行完毕()方法。如果在一个类的< clinit >()方法中有耗时很长的操作，那就

  可能造成多个进程阻塞，在实际应用中这种阻塞往往是很隐蔽的。

  public class ThreadInitTest {
      public static void main(String[] args) {
          Runnable script = new Runnable() {
              public void run() {
                  System.out.println(Thread.currentThread() + "start");
                  DeadLoopClass dlc = new DeadLoopClass();
                  System.out.println(Thread.currentThread() + " run over");
              }
          };
          Thread thread1 = new Thread(script);
          Thread thread2 = new Thread(script);
          thread1.start();
          thread2.start();
      }
  }
  
  class DeadLoopClass {
      static {
          if (true) {
              System.out.println(Thread.currentThread() + "init DeadLoopClass");
              while (true) {
              }
          }
      }
  }
  

  注意4：

  其他线程虽然会被阻塞，但如果执行＜clinit＞()方法的那条线程退出＜clinit＞()方法后，其他线程唤醒后则不会再次进入＜clinit＞()方法。同一个类加载器下，一个类型只会被初始化一 次。

  初始化发生的时机

  概括得说，类初始化是【懒惰的】

  • main 方法所在的类，总会被首先初始化
  • 首次访问这个类的静态变量或静态方法时
  • 子类初始化，如果父类还没初始化，会引发
  • 子类访问父类的静态变量，只会触发父类的初始化
  • Class.forName
  • new 会导致初始化

  不会导致类初始化的情况

  • 访问类的 static final 静态常量（基本类型和字符串）不会触发初始化
  • 类对象.class 不会触发初始化
  • 创建该类的数组不会触发初始化
  • 类加载器的 loadClass 方法
  • Class.forName 的参数 2 为 false 时

• 实验代码：

  class Fu {
      static int a = 0;
      static {
          System.out.println("a init");
      }
  }
  
  class Zi extends Fu {
      final static double b = 5.0;
      static boolean c = false;
      static {
          System.out.println("b init");
      }
  }
  

• 验证（实验时请先全部注释，每次只执行其中一个）

  public class InitTest {
      static {
          System.out.println("main init");
      }
      public static void main(String[] args) throws ClassNotFoundException {
          // 1. 静态常量（基本类型和字符串）不会触发初始化
          System.out.println(Zi.b);
          // 2. 类对象.class 不会触发初始化
          System.out.println(Zi.class);
          // 3. 创建该类的数组不会触发初始化
          System.out.println(new Zi[0]);
          // 4. 不会初始化类 Zi，但会加载 Zi、Fu
          ClassLoader cl = Thread.currentThread().getContextClassLoader();
          cl.loadClass("com.coder404.demo3.Zi");
          // 5. 不会初始化类 Zi，但会加载 Zi、Fu
          ClassLoader c2 = Thread.currentThread().getContextClassLoader();
          Class.forName("com.coder404.demo3.Zi", false, c2);
  
          // 1. 首次访问这个类的静态变量或静态方法时
          System.out.println(Fu.a);
          // 2. 子类初始化，如果父类还没初始化，会引发
          System.out.println(Zi.c);
          // 3. 子类访问父类静态变量，只触发父类初始化
          System.out.println(Zi.a);
          // 4. 会初始化类 Zi，并先初始化类 Fu
          Class.forName("com.coder404.demo3.Zi");
      }
  }
  

关注公众号获取最新内容