类加载 之01 类的加载时机

类加载 之01 类的加载时机

概要

1. 概述：什么是类加载
2. 类的生命周期
3. 类的初始化

1. 概述

我们知道class文件存储描述java文件中的对应的信息，（这是相对Java来说的，class不只可以描述java代码）但是现在只是存储了必要的信息，如果要运行，最终都是要加载到虚拟机之后才能运行和使用。

什么是类加载？ 虚拟机把描述类的数据从class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的java类型（在java中是java.lang.Class，每个对象都可以使用”.class”获取到），这就是虚拟机的类加载机制。

同时与那些编译时需要进行链接工作的语言不同，在Java语言里面，类型的加载、链接和初始化过程都是在程序运行期间完成的，这种策略虽然会令类加载时稍微增加一些性能开销，但是会为java应用程序高度的灵活性。Java天生具有可以动态扩展的特性就是依赖运行期动态加载和动态链接这个特点实现的。

2. 类的生命周期

类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载、验证、准备、解析、初始化、使用和卸载七个阶段。它们开始的顺序如下图所示：

其中类加载的过程包括了加载、验证、准备、解析、初始化五个阶段。(这里需要注意一点，我们现在说的是类加载，加载只是类加载过程中的一个阶段)在这五个阶段中，加载、验证、准备和初始化这四个阶段发生的顺序是确定的，而解析阶段则不一定，它在某些情况下可以在初始化阶段之后开始，这是为了支持 Java 语言的运行时绑定（也成为动态绑定或晚期绑定）。另外注意这里的几个阶段是按顺序开始，而不是按顺序进行或完成，因为这些阶段通常都是互相交叉地混合进行的，通常在一个阶段执行的过程中调用或激活另一个阶段。

这里简要说明下 Java 中的绑定：绑定指的是把一个方法的调用与方法所在的类(方法主体)关联起来，对 Java 来说，绑定分为静态绑定和动态绑定：

• 静态绑定：即前期绑定。在程序执行前方法已经被绑定，此时由编译器或其它连接程序实现。针对 Java，简单的可以理解为程序编译期的绑定。Java 当中的方法只有 final，static，private 和构造方法是前期绑定的。
• 动态绑定：即晚期绑定，也叫运行时绑定。在运行时根据具体对象的类型进行绑定。在 Java 中，几乎所有的方法都是后期绑定的。

3. 类的初始化

在虚拟机规范中并没有规定什么情况下开始类加载过程的第一个阶段，就是加载阶段。但是在虚拟机规范中有严格的规定什么情况下必须对类进行初始化，而加载、验证和准备自然需要在此之前开始：所以我们可以根据此来推测出加载是在什么时候开始，下面5条就是虚拟机规范中规定的：

• 遇到 new、getstatic、putstatic、invokestatic 这四条字节码指令时，如果类还没有进行过初始化，则需要先触发其初始化。生成这四条指令最常见的 Java 代码场景是：使用 new 关键字实例化对象时、读取或设置一个类的静态字段（static）时（被 static 修饰又被 final 修饰的，已在编译期把结果放入常量池的静态字段除外）、以及调用一个类的静态方法时。
• 使用 Java.lang.refect 包的方法对类进行反射调用时，如果类还没有进行过初始化，则需要先触发其初始化。
• 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
• 当虚拟机启动时，用户需要指定一个要执行的主类，虚拟机会先执行该主类。
• 当使用JDK1.7的动态语言支持时，如果一个java.lang.invoke.MethodHandlers实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的累没有进行过初始化，则需要先触发其初始化。

虚拟机规定只有这五种情况才会触发类的初始化，称为对一个类进行主动引用，除此之外所有引用类的方式都不会触发其初始化，称为被动引用。下面举一些例子来说明主动引用和被动引用

主动引用 1 - main 方法在初始类中

代码示例：

public class OptimisticReference0 {   
   static {        
       System.out.println(OptimisticReference0.class.getSimpleName() + " is 
                          referred!");   
  }   
      public static void main(String[] args) {  
           System.out.println();   
       }
   }

运行结果：

OptimisticReference0 is referred!

主动引用 2 – 创建子类会触发父类的初始化

代码示例：

public class OptimisticReference1 {   
      public static class Parent {        
          static {           
                   System.out.println(Parent.class.getSimpleName() 
                          + " is referred!");      
          }   
       }   
       public static class Child extends Parent {   
           static {            
                    System.out.println(Child.class.getSimpleName() + " is 
                          referred!");   
            }    
       }  
       public static void main(String[] args) {      
               new Child();    
       }
}

运行结果：

Parent is referred! Child is referred!

主动引用 3 – 访问一个类静态变量

代码示例：

public class OptimisticReference2 { 
      public static class Child {  
           protected static String name;     
            static {           
                  System.out.println(Child.class.getSimpleName() +
                          " is referred!");            
                   name = "Child";     
               }  
         }    
         public static void main(String[] args) {    
                  System.out.println(Child.name); 
         }
}

运行结果：

Child is referred! Child

主动引用 4 – 对类的静态变量进行赋值

代码示例：

public class OptimisticReference3 {  
  `   public static class Child {   
              protected static String name;      
               static {            
                  System.out.println(Child.class.getSimpleName() +
                      " is referred!");        
                 }   
       }    
       public static void main(String[] args) {  
              Child.name = "Child";    
       }
}

运行结果：

Child is referred!

主动引用 5 – 使用 java.lang.reflect 包提供的反射机制

代码示例：

public class OptimisticReference4 {  
      public static void main(String[] args) throws ClassNotFoundException {   

                          Class.forName("org.ostenant.jdk8.learning.
                          examples.reference.optimistic.Child");   
       }
}

运行结果：

Child is referred!

被动引用例子

通过子类引用父类中的静态字段，这时对子类的引用为被动引用，因此不会初始化子类，只会初始化父类：

/**
* 被动使用类字段演示一：
* 通过自雷引用弗雷的静态字段，不会导致子类初始化
**/
class Father{  
   public static int m = 33;  
   static{  
       System.out.println("父类被初始化");  
   }  
}  

class Child extends Father{  
   static{  
       System.out.println("子类被初始化");  
   }  
}  

public class StaticTest{  
   public static void main(String[] args){  
       System.out.println(Child.m);  
   }  
}  

执行后输出的结果如下：

父类被初始化
   33

对于静态字段，只有直接定义这个字段的类才会被初始化，因此，通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。至于是否要触发子类的加载和验证，在虚拟机规范中并未明确规定，这点取决于虚拟机的具体实现。对于Sun HotSpot虚拟机来说，可通过-XX：+TraceClassLoading参数观察到此操作会导致子类的加载。

常量在编译阶段会存入调用它的类的常量池中，本质上没有直接引用到定义该常量的类，因此不会触发定义常量的类的初始化：

/***
* 被动使用累字段演示二：
* 常量在变异阶段会存入调用类的敞亮池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的累
* 进行初始化。
*
**/
class Const{  

   public static final String NAME = "我是常量";  
   static{  
       System.out.println("初始化Const类");  
   }  
}  

public class FinalTest{  
   public static void main(String[] args){  
       System.out.println(Const.NAME);  
   }  
}  

执行后输出的结果如下：

我是常量

虽然程序中引用了 const 类的常量 NAME，但是在编译阶段将此常量的值“我是常量”存储到了调用它的类 FinalTest 的常量池中，对常量 Const.NAME 的引用实际上转化为了 FinalTest 类对自身常量池的引用。也就是说，实际上 FinalTest 的 Class 文件之中并没有 Const 类的符号引用入口，这两个类在编译成 Class 文件后就不存在任何联系了。

通过数组定义来引用类，不会触发类的初始化：

class Const{  
   static{  
       System.out.println("初始化Const类");  
   }  
}  

public class ArrayTest{  
   public static void main(String[] args){  
       Const[] con = new Const[5];  
   }  
}  

执行后不输出任何信息，说明 Const 类并没有被初始化。

但这段代码里触发了另一个名为“LLConst”的类的初始化，它是一个由虚拟机自动生成的、直接继承于java.lang.Object 的子类，创建动作由字节码指令 newarray 触发，很明显，这是一个对数组引用类型的初初始化，而该数组中的元素仅仅包含一个对 Const 类的引用，并没有对其进行初始化。如果我们加入对 con 数组中各个 Const 类元素的实例化代码，便会触发 Const 类的初始化，如下：

class Const{  
   static{  
       System.out.println("初始化Const类");  
   }  
}  

public class ArrayTest{  
   public static void main(String[] args){  
       Const[] con = new Const[5];  
       for(Const a:con)  
           a = new Const();  
   }  
}  

这样便会得到如下输出结果：

初始化Const类

根据四条规则的第一条，这里的 new 触发了 Const 类。

最后看一下接口的初始化过程与类初始化过程的不同。

接口也有初始化过程，上面的代码中我们都是用静态语句块来输出初始化信息的，而在接口中不能使用“static{}”语句块，但编译器仍然会为接口生成类构造器，用于初始化接口中定义的成员变量（实际上是 static final 修饰的全局常量）。

二者在初始化时最主要的区别是：当一个类在初始化时，要求其父类全部已经初始化过了，但是一个接口在初始化时，并不要求其父接口全部都完成了初始化，只有在真正使用到父接口的时候（如引用接口中定义的常量），才会初始化该父接口。这点也与类初始化的情况很不同，回过头来看第 2 个例子就知道，调用类中的 static final 常量时并不会 触发该类的初始化，但是调用接口中的 static final 常量时便会触发该接口的初始化。

参考

1. 极客学院
2. 深入理解java虚拟机