JVM学习篇章（1）

最新推荐文章于 2022-08-02 16:58:36 发布

科比也爱写代码

最新推荐文章于 2022-08-02 16:58:36 发布

阅读量126

点赞数

分类专栏： jvm 文章标签： java 后端

本文链接：https://blog.csdn.net/qq_37805322/article/details/109067698

版权

jvm 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

作者：paul 联系方式：paul_bryant@163.com

1.JVM的整体架构

上图主要是针对HotSpot VM（目前市面上高性能的虚拟机代表之一）

注意：方法区和堆是多线程共有，java栈、本地方法栈、程序计数器是每个线程独有的。

2.JVM的架构模型

栈指令架构	寄存器指令架构
设计和实现更简单，适用于资源受限的系统，可移植性更好，更好的跨平台	指令集架构完全依赖硬件，可移植性差
使用零地址指令方式分配	大部分情况下采用一地址指令、二地址指令、三地址指令
由于大部分是零地址，执行过程依赖操作栈，指令集更小，编译器容易实现	花费更少的指令去完成一项操作
八位地址	16位地址

这里我们解释下指令集和指令，我们写了一个测试类

package com.paul.jvm;

public class Main {
    public static void main(String[] args) {
	  int i = 2 + 3;
    }
}

我们运行将之编译成class文件，在进行反编译

javap -v Main.class

我们可以看到main方法里面的指令有三行，但是如果是寄存器就两行

mov eax,2 //将寄存器的值置为2
add eax,3 //将寄存器的值加上3

那什么是零地址指令，一地址指令、二地址指令、三地址指令？

上图的就是一地址的指令，就是在操作的时候操作数前面加上了地址，零地址则是没有地址只有操作数。

3.类加载器及类加载过程

我们可以看到.class文件需要加载到运行时数据区，就需要类加载子系统，有下面的三个过程

 加载（loading）-----> 链接（linking）----->初始化（initialization）
     链接： 1.验证 ->2.准备->3.解析

类加载器子系统负责从文件系统或网络中加载Class文件，该文件在文件开头有特定的文件标识（魔数值），至于时候可以运行则有执行引擎去决定，加载的类信息存放在一块被称为方法区的内存空间，除了类信息，方法区还存放着运行时常量池信息，可能还包括字符串字面量和数字常量（这部分常量信息是Class文件中常量池部分的内存映射）

1.类加载过程

1.通过类的全限定名获取定义此类的二进制字节流
2.将这个字节流所代表的静态存储结构转化成方法区运行时数据结构
3.在内存中生成一个代表这里类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口（这时生成了Class对象）

加载.class文件的方式：

1.从本地系统直接加载,本地运行
2.通过网络获取，Web Applet
3.从zip压缩包中读取，jar、war包
4.运行时计算生成，动态代理技术
5.有其他文件生成，jsp应用
6.从专有数据库中获取，比较少见
7.从加密文件获取

2.链接

验证（Verify）:前面类加载的时候已经验证了Class文件的魔数，验证的目的则是确保Class文件的字节流中包含信息符合当前虚拟机，保证被加载类类的正确性，不会危害虚拟机自身安全。

验证：文件格式验证、元数据验证、字节码验证、符号引用验证

准备（Prepare）：为类变量分配内存并且设置该类变量的默认初始值即零值（初始化阶段会将类变量的值重新赋值为用户定义的值），不包含使用final修饰的static,因为final在编译的时候就会分配了，准备阶段会显示初始化，不会为实例变量分配初始化，类变量会分配在方法区中，实例变量则是会跟随对象一直分配到Java堆中。

解析（Resolve）：将常量池内的符号引用转换为直接引用的过程，实际上解析操作往往会伴随着JVM在执行完初始化之后在执行，符号引用就是一组符号来描述所引用的目标，符号引用的字面量形式明确定义在《java虚拟机规范》的Class文件格式中，直接引用则是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。

解析动作主要是针对类或接口、字段、类方法、接口方法、方法类型等等、对应常量池中的CONSTANT_Class_info、CONSTANT_Fieldref_info、CONSTANT_Methodref_info等

3.初始化

初始化阶段就是执行类构造器方法<cinit>()的过程，此方法不需要定义，是javac编译器自动收集类中的所有的类变量的赋值动作和静态代码块的语句合并而来的，按照语句在源文件出现的顺序执行，<clinit>()不同于类的构造器，构造器是虚拟机视角下的<init>（），若类有父类JVM会先保证子类的<cinit>（）执行前，父类的<clinit>()已经执行完毕，虚拟机必须保证一个类的<clinit>()方法在多线程下被同步加锁。

<cinit>类中的所有的类变量的赋值动作和静态代码块的语句合并而来的

如果没有呢？

没有类变量则不存在<cinit>方法

4.常见的类加载器

引导类加载器（Bootstrap ClassLoader）

扩展类加载器（Extemsion ClassLoader）

应用类加载器（AppClassLoader）

package com.paul.DesignParrent.chapter2;
/**
 * @ClassName : ClassLoaderTest1  //类名
 * @Description : 加载器测试类1  //描述
 * @Author : luokun
 * @Date: 2020/9/29  16:18
 */
public class ClassLoaderTest1 {

    public static void main(String[] args) {
        // 得到加载ClassLoaderTest1的加载器
        ClassLoader classLoader = ClassLoaderTest1.class.getClassLoader();
        System.out.println( classLoader);// sun.misc.Launcher$AppClassLoader@18b4aac2 系统类/应用类加载器

        ClassLoader parentClassLoader = classLoader.getParent();
        System.out.println(parentClassLoader);  // sun.misc.Launcher$ExtClassLoader@1b6d3586 扩展类加载器

        ClassLoader rootClassLoader = parentClassLoader.getParent();
        System.out.println(rootClassLoader); // null bootstrap classloader 引导类加载器

        ClassLoader classLoader1 = String.class.getClassLoader();
        System.out.println(classLoader1); // null bootstrap classloader 引导类加载器
    }
}

加载器	加载内容
引导类加载器（Bootstrap ClassLoader）	①使用c/c++实现嵌套在JVM内部 ②加载java的核心可以（JAVA_HOME/jre/lib/rt.jar、resources.jar、或sun.boot.class.path路径下的内容），用于提供JVM自身需要的类 ③不继承java.lang.ClassLoader，没有父加载器 ④加载扩展类加载器和应用程序加载器，并指定为他们的父加载器 ⑤只加载包名为java、javax、sun等开头的类
扩展类加载器（Extemsion ClassLoader）	①java语言编写的，由sun.misc.Launcher$ExtClassLoader实现（sun.misc.Launcher的内部类）②派生于ClassLoader，父加载器为启动类加载器③从java.ext.dirs系统属性所指定的目录中加载类库或从JDK的安装目录jre/lib/ext子目录（扩展目录）下加载类库，如果用户创建的JAR包也放在此目录下，也会自动由扩展类加载器加载
应用类加载器（AppClassLoader）	①java语言编写的，由sun.misc.Launcher$AppClassLoader实现（sun.misc.Launcher的内部类）②派生于ClassLoader，父加载器为启动类加载器③负责加载环境变量classpath或系统属性java.class.path指定路径下的类库 ④是程序默认的类加载器，一般来说，java应用的类都是由它来完成的 ⑤可以通过ClassLoader或getSystemClassLoader（）来获取改类加载器

演示加载案例：

package com.paul.DesignParrent.chapter2;

import sun.misc.Launcher;
import sun.misc.Resource;
import sun.misc.URLClassPath;

import java.net.URL;

/**
 * @ClassName : ClassLoaderTest2  //类名
 * @Description : 加载器测试2  //描述
 * @Author : luokun
 * @Date: 2020/10/8  10:57
 */
public class ClassLoaderTest2 {
    public static void main(String[] args) {
        System.out.println("获取系统类加载器开始");
        URL[] urLs = Launcher.getBootstrapClassPath().getURLs();
        for (URL urL : urLs) {
            System.out.println(urL);
        }
        System.out.println("获取系统类加载器结束");

        System.out.println("获取扩展类加载器开始");
        String property = System.getProperty("java.ext.dirs");
        System.out.println(property);
        System.out.println("获取扩展类加载器结束");

    }
}
输出结果：
获取系统类加载器开始
file:/D:/devTool/javaJdk/jdk1.8.0_251/jre/lib/resources.jar
file:/D:/devTool/javaJdk/jdk1.8.0_251/jre/lib/rt.jar
file:/D:/devTool/javaJdk/jdk1.8.0_251/jre/lib/sunrsasign.jar
file:/D:/devTool/javaJdk/jdk1.8.0_251/jre/lib/jsse.jar
file:/D:/devTool/javaJdk/jdk1.8.0_251/jre/lib/jce.jar
file:/D:/devTool/javaJdk/jdk1.8.0_251/jre/lib/charsets.jar
file:/D:/devTool/javaJdk/jdk1.8.0_251/jre/lib/jfr.jar
file:/D:/devTool/javaJdk/jdk1.8.0_251/jre/classes
获取系统类加载器结束
获取扩展类加载器开始
D:\devTool\javaJdk\jdk1.8.0_251\jre\lib\ext;C:\WINDOWS\Sun\Java\lib\ext
获取扩展类加载器结束

5.自定义类加载器

一.作用：
    1.隔离加载类
    2.修改类的加载方式（需要的时候在加载）
    3.扩展加载源
    4.防止源码泄露

二.实现步骤
    1.继承抽象类ClassLoader类，实现自己的类加载器
    2.在JDK1.2之前，在自定义类加载器时，总会去继承ClassLoader类重写loadClass（）方法，从而实现自定义的类加载器，但是在JDK1.2之后建议将自定义的类加载逻辑写在findClass()方法
    3.没有复杂的要求，可以直接继承URLClassLoader类

6.双亲委派机制

java虚拟机对class文件采用的是按需加载的方式，当需要使用该类的时候才会将对应的class文件加载到内存生成class对象，而且加载某个类的class文件时，java虚拟机采用的是双亲委派机制，即把请求交友父类加载处理，他是一种任务委派模式。

1.如果一个类加载器收到类加载请求，现将该请求委托给父类的加载器去执行
2.如果父类加载器还存在父类加载器，则进一步委托，依次递归，请求最终到达最上面的启动类加载器
3.如果父类加载器可以完成则由父类加载，子类才会自己去加载
    
优势：
1.避免类的重复加载
2.保护程序安全，防止核心API被随意修改

实验1

1.自定义String看是否是使用我们自定义的String

# 自定义String
package java.lang;

/**
 * @ClassName : String  //类名
 * @Description : 自定义字符串类  //描述
 * @Author : luokun
 * @Date: 2020/10/12  9:23
 */
public class String {
    public String(){
        System.out.println("我是自定义String类");
    }
}

# 实验类
package com.paul.DesignParrent.chapter2;

/**
 * @ClassName : ClassLoaderTes4  //类名
 * @Description : 双亲委派机制  //描述
 * @Author : luokun
 * @Date: 2020/10/12  9:22
 */
public class ClassLoaderTes4 {
    public static void main(String[] args) {
        String s = new String();
    }
}

结果：没有任何输出，说明双亲委派向上找，最终由启动类加载器加载了

实验2

1.在实现String类中加入main方法（JDK中String类无main方法）

package java.lang;

/**
 * @ClassName : String  //类名
 * @Description : 自定义字符串类  //描述
 * @Author : luokun
 * @Date: 2020/10/12  9:23
 */
public class String {
    public String(){
        System.out.println("我是自定义String类");
    }

    public static void main(String[] args) {
        System.out.println("我是自定义String类的main");
    }
}

# 输出结果
 错误: 在类 java.lang.String 中找不到 main 方法, 请将 main 方法定义为:
   public static void main(String[] args)
否则 JavaFX 应用程序类必须扩展javafx.application.Application

结果：报错，也从侧面说明使用了双亲委派机制

7.沙箱安全机制

上面实验2中在自定义String类中加入了main（）方法后，报错显示没有main（）方法，对java核心的源代码的保护了，这就是沙箱安全机制

8.类的主动使用和被动使用

在JVM中表示两个class对象是否为同一个类存在两个必要的条件：

1.类的完整类名必须一致，包括包名。

2.加载这个类的ClassLoader(指classLoader对象)必须相同

所以即使两个类对象来源同一个Class文件，被同一个虚拟机记载，但是加载的ClassLoader实例对象不同，那么这两个类对象也是步行等的

JVM必须知道一个类是否是启动类加载器加载还是用户自定义的类加载器加载的，因为当时用户类加载器加载的，jvm会将该类加载器的的一个引用作为类型信息的一部分保存在方法区中。当解析一个类型到另一个类型的引用的时候，jvm需要保证两个类型的类加载器是相同的。

类的主动使用有：

1.创建类的实例

2.访问某个类或接口的静态变量，或者对静态变量赋值

3.调用类的静态方法

4.反射（如：Class.forName("com.paul")）

5.初始化一个类的子类

6.java虚拟机启动时被标明为启动类

7.jdk7之后提供动态语言支持：java.lang.invoke.MethodHandler实例的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic句柄对应的类没有初始化则进行初始化

除了以上7种情况，其余都是类的被动使用，都不会导致类的初始化

更多内容已上传公众号【那条转弯的路】

科比也爱写代码

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JVM学习篇章（1）

作者：paul 联系方式：paul_bryant@163.com1.JVM的整体架构上图主要是针对HotSpot VM（目前市面上高性能的虚拟机代表之一）注意：方法区和堆是多线程共有，java栈、本地方法栈、程序计数器是每个线程独有的。2.JVM的架构模型栈指令架构寄存器指令架构设计和实现更简单，适用于资源受...
复制链接

扫一扫

专栏目录