java基础知识（二）jvm类加载

朴灿烈づ我的快乐病毒、 2022-06-06 07:39 143阅读 0赞

最近想了解一下jvm，这里简单的做一下笔记。

## 一、类的初始化 ##

### 在java中类的加载初始化主要分为下面三个步骤： ###

*  加载  
    寻找并加载二进制数据
 *  连接  
    验证：确保被加载的类的正确性  
    准备：为类的静态变量分配内存，并将其初始化为默认值  
    解析：把类中的符号引用转化为直接引用
 *  初始化  
    为类的静态变量赋予正确的初始化值//这里指的是程序员给的初始值

下面的内容将分别从上面的几个方面展开。

## 二、类的加载 ##

### 类的初始化只会在类的初次主动使用才会进行。 ###

类的主动使用（6种情况）

*  创建类的示例
 *  访问类的某个类或者接口的静态变量，或者对静态变量赋值
 *  调用类的静态方法
 *  反射（Class.forName(“”);）
 *  初始化一个类的实例
 *  java虚拟机启动时被标明为启动类的类（就是执行的main方法类）

即是说只有发生上面6中情况中的一种才会导致类的初始化，其他的情况类是不会运行的。jvm会预先加载类文件，如果类文件缺失或者存在错误的时候，jvm是不会报错的，只有在类的第一次初始化的时候才会报错，所以项目中有时候存在有错误的文件的时候项目也是可以运行的，只有运行到错误的地方才会报错，之前的地方都不会报错。

类的加载是指将类的.class文件中的二进制数据读入到内存中，将其放在运行时的方法区内，然后在堆内创建一个java.lang.Class对象用来封装在方法区内的数据结构。（关于堆，栈，方法区等在后续的文章中会继续做笔记的）

寻找.class 的文件主要是从项目下生成的.class文件和引入的jar包中.class文件。

Java 虚拟机自带了以下几种加载器。

根(Bootstrap) 类加载器: 该加载器没有父加载器。它负责加载虚拟机的核心类库,如java.lang.\* 等。例如从例程10-4( Sample.java )可以看出，java.lang.0bject就是由根类加载器加载的。根类加载器从系统属性sun.boot.class.path 所指定的目录中加载类库。根类加载器的实现依赖于底层操作系统，属于虚拟机的实现的一部分，它并没有继承java.lang.ClassLoader 类。

扩展(Extension) 类加载器:它的父加载器为根类加载器。它从java.ext.dirs系统属性所指定的目录中加载类库，或者从JDK 的安装目录的jre\\lib\\ext 子目如果把用户创建的JAR 文件放在这个目录下,录(扩展目录) 下加载类库,也会自动由扩展类加载器加载。扩展类加载器是纯Java 类，是java.lang.ClassLoader 类的子类。

系统(System) 类加载器: 也称为应用类加载器，它的父加载器为扩展类加  
载器。它从环境变量classpath 或者系统属性java.class.path 所指定的目录中加载类，它是用户自定义的类加载器的默认父加载器。系统类加载器是纯Java类，是:java,lang.ClassLoader 类的子类。

网上盗的图片：主要是说明每个加载器对应加载的文件：

![这里写图片描述][SouthEast]

在类加载器中，遵循父亲委托机制，简单讲就是能用父亲加载器的就是用父亲加载器，不能用父亲加载器的就用自己的加载器。同时在加载器中的父子关系并不一定是继承关系，只是说明了加载顺序而已，即是先用哪个加载器，再用哪个加载器，在自定义的加载器中可以指明父亲加载器。

用代码小小的测试一下：

package jvm;
    
    public class _ClassLoader { 
    
        public static void main(String[] args) throws Exception {
            test01();
            //test02();
        }
    
        /** * 输出的是null，表示用的是根类加载器，（用null表示根类加载器） * @throws Exception */
        public static void test01() throws Exception {
    
            // 创建一个对象的其中两种方式
            Class clazz = Class.forName("java.lang.String");
            Class clazzz = _ClassLoader.class.getClassLoader().loadClass("java.lang.String");
            System.out.println(clazzz.getClassLoader());
    
        }
    
        /** * 输出的是sun.misc.Launcher$AppClassLoader@73d16e93 * 表示自己定义的类是有AppClassLoader加载的 * @throws Exception */
        public static void test02() throws Exception {
            Class clazz = Class.forName("jvm.C");
            System.out.println(clazz.getClassLoader());
        }
    
    }
    
    class C {
    }

## 二、类的连接 ##

### 验证 ###

验证阶段是确保被加载的类的正确性，主要通过下面几个方面验证：

*  类文件的结构检查：确保类文件遵从Java类文件的固定格式。
 *  语义检查：确保类本身符合Java语言的语法规定，比如验证final类型的类没有子类，以及final类型的方法没有被覆盖。
 *  字节码验证：确保字节码流可以被Java虚拟机安全的执行。字节码流代表Java方法（包括静态方法和实例方法），它是由被称做操作码的单字节指令组成的序列，每一个操作码后都跟着一个或多个操作数。字节码验证步骤检查每个操作码是否合法，即是否有着合法的操作数。
 *  二进制兼容的验证：确保相互的类之间协调一致。例如在Worker类的gotoWork()方法中会调用Car类的run()方法。Java虚拟机在验证Worker类时，会检查在方法区内是否存在Car类的run()方法，假如不存在（当Worker类和Car类的版本不兼容，就会出现这种问题），就会抛出NosuchMethodError错误。

### 准备 ###

准备阶段是为类的静态变量分配内存，并将其初始化为默认值：

<table> 
 <thead> 
  <tr> 
   <th align="left">类型</th> 
   <th align="left">所占内存大小</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">boolean</td> 
   <td align="left">1字节</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td align="left">byte</td> 
   <td align="left">1字节</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td align="left">short</td> 
   <td align="left">2字节</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td align="left">char</td> 
   <td align="left">2字节</td> 
   <td>\u0000(输出是一个方框)</td> 
  </tr> 
  <tr> 
   <td align="left">int</td> 
   <td align="left">4字节</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td align="left">long</td> 
   <td align="left">8字节</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td align="left">float</td> 
   <td align="left">4字节</td> 
   <td>0.0f</td> 
  </tr> 
  <tr> 
   <td align="left">double</td> 
   <td align="left">16字节</td> 
   <td>0.0d</td> 
  </tr> 
 </tbody> 
</table>

### 解析 ###

在解析阶段，Java虚拟机会把类的二进制数据中的符号引用替换为直接引用。

在Worker类的二进制数据中，包含了一个对Car类的run()方法的符号引用，它由run()方法的全名和相关描述符组成。在解析阶段，Java虚拟机会把这个符号引用替换为一个指针，该指针指向Car类的run()方法在方法区内的内存位置，这个指针就是直接引用。

## 三、类的初始化 ##

初始化阶段主要是为类的静态变量赋予正确的初始值。

在初始化阶段，Java虚拟机执行类的初始化语句，为类的静态变量赋予初始值。在程序中，静态变量的初始化有两种途径：（1）在静态变量的声明处进行初始化；（2）在静态代码块中进行初始化。例如在以下代码中，静态变量a和b都被显示初始化，而静态变量c没有被明显初始化，它将保持默认值0。

public class sample{ 
        private static int a=1;//在静态变量声明处初始化
        private static int b;
        private static int c;
        static{
            b=2;//在静态代码块中初始化
        }
    }

## 四、类的初始化顺序 ##

子类只有在父类初始化完成之后才会初始化，在第一次初始化子类的时候，会先去检查父类是否初始化，若未初始化，则先初始化父类，在初始化子类。但是这一点不适合在接口：

*  在初始化一个类时，并不会先初始化他所实现的父类；
 *  在初始化一个借口的时候，并不是先初始化他的父接口；

只有当程序首次使用特定接口的静态变量时，才会导致该接口的初始化；

属性、方法、构造方法和自由块都是类中的成员，在创建类的对象时，类中各成员的执行顺序：[http://blog.csdn.net/lgfeng218/article/details/7606735][http_blog.csdn.net_lgfeng218_article_details_7606735]  
1.父类静态成员和静态初始化快，按在代码中出现的顺序依次执行。  
2.子类静态成员和静态初始化块，按在代码中出现的顺序依次执行。  
3. 父类的实例成员和实例初始化块，按在代码中出现的顺序依次执行。  
4.执行父类的构造方法。  
5.子类实例成员和实例初始化块，按在代码中出现的顺序依次执行。  
6.执行子类的构造方法。

## 五、一些简单的示例： ##

### 示例1： ###

public class Main{ 
        public static void main(String[] args) {
            System.out.println("i=" + test.i + " j=" + test.j);//i=1 j=0
    
            System.out.println("i=" + test1.i + " j=" + test1.j);//i=1 j=1
        }
    
    }
    
    class test {
        private static test _test = new test();
        public static int i;
        public static int j = 0;
    
        private test() {
            i++;
            j++;
        }
    
    }
    class test1 {
        public static int i;
        public static int j = 0;
        private static test1 _test1 = new test1();
    
        private test1() {
            i++;
            j++;
        }
    }

下面两个类唯一的区别只有`private static test1 _test = new test1();`这个语句的位置而已，但是输出的结果却是完全不同的。原因就是连接和初始化过程。

在test中，类在初始化的时候，先加载了三个变量\_test,i,j这三个，然后分别分配空间，并初始化为默认值，分别为null，0,0这三个值，然后，先进行\_test的初始化，即对i和j自增，然后i，j的值变为1,1，而后在j初始化的时候j的值重新被赋值为0，所以输出的是`i=1 j=0`

在test1类中同理，只是在初始化的顺序有不同。默认值i，j，\_test1的值0,0，null，程序员没有指定i的值，所以i还是等0，程序员指定了j=0，所以j等于0，而后初始化\_test1的值，对i，j的值自增，故输出`i=1 j=1`

### 示例2： ###

package jvm;
    
    public class Main{ 
    
        public static void main(String[] args) {
            System.out.println(test01.i);//2
            System.out.println(test02.i);//2
            System.out.println(test03.i);//test03 2
        }
    
    }
    
    class test01 {
        public static final int i = 2;
    
        static {
            System.out.println("test01");// 直接把2赋值给j，故此时不会输出静态代码块，即不会加载当前类
        }
    }
    
    class test02 {
        public static final int i = 6 / 3;// 编译器直接计算成6/3=2，然后把2赋值给j，故此时不会输出静态代码块，即不会加载当前类
    
        static {
            System.out.println("test02");
        }
    }
    
    class test03 {
        public static final int i = (int)(Math.random()*10);// 需要在运行的时候才能获得j的值，所以这个时候会输出静态代码块，即会加载当前类
    
        static {
            System.out.println("test03");
        }
    }

在类的调用的时候，如果给静态变量直接赋值或者编译器能直接计算出结果的值的话，则不会导致类的初始化，如果需要运行`public static final int i = (int)(Math.random()*10);`才能知道的话则会导致类的初始化。

### 示例3： ###

package jvm;
    
    public class 不会初始化子类 { 
    
    
        public static void main(String[] args) {
    
            //由于下面的变量和方法都是在parent中定义的，故使用child调用的时候，也不会加载child类
            System.out.println(child.a);
            child.dosomething();
        }
    }
    
    class parent {
        public static int a = 3;
    
        public static  void dosomething() {
            System.out.println("parent dosomething");
        }
    
        static {
            System.out.println("parent");
        }
    }
    
    class child extends parent {
        static {
            System.out.println("cjild");
        }
    }

只有当程序访问的静态变量或者静态方法确实在当前类或当前接口中定义的时候，才被认为是类或者接口的主动使用；

### 示例4： ###

package jvm;
    
    public class _ClassLoaderTest { 
    
        public static void main(String[] args) throws ClassNotFoundException {
            ClassLoader loader = ClassLoader.getSystemClassLoader();
            Class<?> clazz = loader.loadClass("jvm.A");
    
            System.out.println("-----------------");
    
            Class<?> clazzz = Class.forName("jvm.A");
    
            /** * 输出： * ----------------- * Load Class A */
        }
    }
    
    class A{
        static{
            System.out.println("Load Class A");
        }
    }

调用ClassLoader类的loadClass方法加载一个类并不是对类的主动使用，不会导致类的初始化；但是使用Class.forName(“”)就是对类的主动使用

[SouthEast]: /images/20220606/32bc9c1d81bd492d8a07de05048a07f1.png
[http_blog.csdn.net_lgfeng218_article_details_7606735]: http://blog.csdn.net/lgfeng218/article/details/7606735