JVM java虚拟机的学习(一)

亦凉 2022-08-04 13:49 257阅读 0赞

java虚拟机与程序的生命周期  
在如下几种情况下，java虚拟机将结束生命周期：

*  执行了System.exit()方法
 *  程序正常执行结束
 *  程序在执行过程中遇到了异常或错误而异常终止
 *  由于操作系统出现错误而导致java虚拟机进程终止

a.加载：查找并加载类的二进制数据  
b.连接

- 验证：确保被加载的类的正确性
     - 准备：为类的静态变量分配内存，并将其初始化为默认值
     - 解析：把类中的符号引用转换成直接引用

c.初始化：为类的静态变量赋予正确的初始值  
![这里写图片描述][20150831110012289]  
java程序对类的使用方式可分为两种

- 主动使用
     - 被动使用

所有的java虚拟机实现必须在每个类或接口被接java程序“首次**主动**使用”时才初始化他们  
主动使用：

- 创建类的实例
     - 访问某个类或接口的静态变量，或者对该静态变量赋值
     - 调用类的静态方法
     - 反射（Class.forName("")）
     - 初始化一个类的子类
     - java虚拟机启动时被标明为启动类的类

除了以上六种情况，其他使用java类的方式都被看做是对类的被动使用， 都不会导致类的初始化

类的加载

类的加载指的是将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个java.lang.Class对象，用来封装类在方法区内的数据结构。
    加载.class文件的方式
    -从本地系统中直接加载
    -通过网络下载.class文件
    -从zip,jar等归档文件中加载.class 文件
    -从专有数据库中提取.class文件
    -将java源文件动态编译.class 文件

![这里写图片描述][20150831115358157]  
有两种类型的类加载器

-java虚拟机自带的加载器
        根类加载器（C++实现）
        扩展类加载器（java）
        系统类加载器（java）
    -用户自定义的类加载器
        java.lang.ClassLoader的子类
        用户可以定制类的加载方式
    *类加载器并不需要等到某个类被“首次主动使用”时再加载它*
    JVM规范允许类加载器在预料某个类将要被使用时就预先加载它， 如果在预选加载的过程中遇到 了.class文件缺失或存在错误，类加载器必须在程序首次主动使用该类时才报告错误。如果这个类一直没有被程序主动使用，那么类加载器就不会报告错误。
    类被加载后，就进入连接阶段。连接就是将已经读入到内存的类的二进制数据合并到虚拟机的运行时环境中去。

类的验证的内容：

类文件的结构检查
        语义检查
        字节码验证

**类的准备**

在准备阶段，java虚拟机为类的静态变量分配内存，并设置默认的初始值。（从上到下）例如对于以下sample类，在准备阶段，将为int类型的静态变量a分配4个字节的内存空间，并且赋予默认值为0，为long类型的静态变量b分配8个字节的内存空间，并且赋予默认值0.

public class Sample{
        private static int a=1;
        public static long b;
        static{
            b=2;
        }
    }

在解析阶段，java虚拟机会把类的二进制数据中的符号引用替换成直接引用。例如在worker类的gotowork（）方法中会引用car类的run方法

public void gotowork(){
        car.run();
    }

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

**类的初始化**

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

public class Sample{
        private static int a=1;
        public static long b;
        public static long c;
        static{
            b=2;
        }
    }

类的初始化步骤

- 假如这个类还没有被加载和连接，那就先进行加载和连接
     - 假如类存在直接的父类，并且这个父类还没有被初始化，那就先初始化直接的父类。
     - 假如类中存在初始化语句，那就依次执行这些初始化语句。

初始化的时机：

- 创建类的实例
    - 访问某个类或接口的静态变量，或者对该静态变量赋值
    - 调用类的静态方法
    - 反射（Class.forName("")）
    - 初始化一个类的子类
    - java虚拟机启动时被标明为启动类的类

*当java虚拟机初始化一个类时，要求它的父类都已经被初始化，但是这条规则并不适用于接口。在初始化一个类时，并不会先初始化它所实现的接口。在初始化一个接口时，并不会先初始化它的父接口。因此，一个父接口并不会因为他的子接口或实现类的初始化而初始化。只有当程序首次使用特定接口的静态变量时，才会导致该接口的初始化*

class Test1{
        public static final int x=6/3;
        static{
            System.out.println("Test1");
        }
    }
    public class Test{
            public static void main(String[] args){
                System.out.println(Test1.x);
            }
    }
    结果是：2
    class Test1{
        public static final int x=new Random().nextInt(100);
        static{
            System.out.println("Test1");
        }
    }
    public class Test{
            public static void main(String[] args){
                System.out.println(Test1.x);
            }
    }
    结果是：
        Test1
        44

前者并没到导致类Test1的初始化，只会对变量进行初始化，static块并没有执行。

public class Test {
        
        static {
            System.out.println("Test");
        }
        public static void main(String[] args) {
    
            Parent parent;
            System.out.println("---------");
            parent=new Parent();
            System.out.println(Parent.a);
            System.out.println(Child.b);
        }
    }
    class Parent{
        
        static int a =3;
        static{
            System.out.println("parent");
        }
    }
    class Child extends Parent{
        
        static int b=4;
        static{
            System.out.println("Child");
        }
    }
    结果是：
    Test
    ---------
    parent
    3
    Child
    4

**在同一个类加载器的条件下，父类初始化后，不会再初始化**

public class Test {
        
        static {
            System.out.println("Test");
        }
        public static void main(String[] args) {
            System.out.println(Child.b);
        }
    }
    class Parent{
        
        static int a =3;
        static{
            System.out.println("parent");
        }
    }
    class Child extends Parent{
        
        static int b=4;
        static{
            System.out.println("Child");
        }
    }
    运行结果：
    Test
    parent
    Child
    4
    
    public class Test {
        
        static {
            System.out.println("Test");
        }
        public static void main(String[] args) {
            System.out.println(Child.a);
        }
    }
    class Parent{
        
        static int a =3;
        static{
            System.out.println("parent");
        }
    }
    class Child extends Parent{
        
        static int b=4;
        static{
            System.out.println("Child");
        }
    }
    运行结果：
    Test
    parent
    3

**只有当程序访问的静态变量过静态方法确实在当前类或当前接口中定义时，才可以认为是对类或接口的主动使用**  
因为a不是Child类，而是父类的静态变量，所以并没有初始化Child类

public class Test {
        public static void main(String[] args) throws ClassNotFoundException {
            ClassLoader loader=ClassLoader.getSystemClassLoader();
            Class<?> clazz=loader.loadClass("test.CL");
            System.out.println("________________________");
            clazz=Class.forName("test.CL");
        }
    }
    
    class CL{
        static{
            System.out.println("Class CL");
        }
    }
    运行结果：
    ________________________
    Class CL

*调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化*

[20150831110012289]: /images/20220731/869b2efa902b4b79a8820889a111d804.png
[20150831115358157]: /images/20220731/0ca3238e36ef4ad494603d87a84a94ef.png