JVM系列笔记--字节码与类加载

最新推荐文章于 2022-03-08 18:45:45 发布
最新推荐文章于 2022-03-08 18:45:45 发布
阅读量199 收藏
点赞数
分类专栏： JVM Java 文章标签： jvm java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44863537/article/details/109585875
版权
Java 同时被 2 个专栏收录
44 篇文章 0 订阅
订阅专栏
JVM
9 篇文章 0 订阅
订阅专栏

一、字节码指令

反编译

  • 可使用javap -v className.class来反编译class文件
    public class Demo3_1 {
    public static void main(String[] args) {
        int a = 10;
        int b = Short.MAX_VALUE + 1;
        int c = a + b;
        System.out.println(c);
    }
}

    Classfile /D:/downloads/资料 解密JVM/代码/jvm/out/production/jvm/cn/itcast/jvm/t3/bytecode/Demo3_1.class
  Last modified 2020-11-2; size 635 bytes
  MD5 checksum 1a6413a652bcc5023f130b392deb76a1
  Compiled from "Demo3_1.java"
public class cn.itcast.jvm.t3.bytecode.Demo3_1
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #7.#25         // java/lang/Object."<init>":()V
   #2 = Class              #26            // java/lang/Short
   #3 = Integer            32768
   #4 = Fieldref           #27.#28        // java/lang/System.out:Ljava/io/PrintStream;
   #5 = Methodref          #29.#30        // java/io/PrintStream.println:(I)V
   #6 = Class              #31            // cn/itcast/jvm/t3/bytecode/Demo3_1
   #7 = Class              #32            // java/lang/Object
   #8 = Utf8               <init>
   #9 = Utf8               ()V
  #10 = Utf8               Code
  #11 = Utf8               LineNumberTable
  #12 = Utf8               LocalVariableTable
  #13 = Utf8               this
  #14 = Utf8               Lcn/itcast/jvm/t3/bytecode/Demo3_1;
  #15 = Utf8               main
  #16 = Utf8               ([Ljava/lang/String;)V
  #17 = Utf8               args
  #18 = Utf8               [Ljava/lang/String;
  #19 = Utf8               a
  #20 = Utf8               I
  #21 = Utf8               b
  #22 = Utf8               c
  #23 = Utf8               SourceFile
  #24 = Utf8               Demo3_1.java
  #25 = NameAndType        #8:#9          // "<init>":()V
  #26 = Utf8               java/lang/Short
  #27 = Class              #33            // java/lang/System
  #28 = NameAndType        #34:#35        // out:Ljava/io/PrintStream;
  #29 = Class              #36            // java/io/PrintStream
  #30 = NameAndType        #37:#38        // println:(I)V
  #31 = Utf8               cn/itcast/jvm/t3/bytecode/Demo3_1
  #32 = Utf8               java/lang/Object
  #33 = Utf8               java/lang/System
  #34 = Utf8               out
  #35 = Utf8               Ljava/io/PrintStream;
  #36 = Utf8               java/io/PrintStream
  #37 = Utf8               println
  #38 = Utf8               (I)V
{
  public cn.itcast.jvm.t3.bytecode.Demo3_1();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 6: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcn/itcast/jvm/t3/bytecode/Demo3_1;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=4, args_size=1
         0: bipush        10
         2: istore_1
         3: ldc           #3                  // int 32768
         5: istore_2
         6: iload_1
         7: iload_2
         8: iadd
         9: istore_3
        10: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
        13: iload_3
        14: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
        17: return
      LineNumberTable:
        line 8: 0
        line 9: 3
        line 10: 6
        line 11: 10
        line 12: 17
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      18     0  args   [Ljava/lang/String;
            3      15     1     a   I
            6      12     2     b   I
           10       8     3     c   I
}
SourceFile: "Demo3_1.java"

执行流程

  • main方法中指明了局部变量表数目、操作数栈的深度、方法参数的数目stack=2, locals=4, args_size=1
    在这里插入图片描述
    1. bipush 10：将一个 byte 压入操作数栈
    2. istore_1：将操作数栈顶数据弹出，存入局部变量表的slot 1
    3. ldc #3：从常量池加载#3数据到操作数栈
    4. istore_2：将操作数栈顶数据弹出，存入局部变量表的slot 2
    5. iload_1：从局部变量表slot 1中取出数据，存入操作数栈中
    6. iload_2
    7. iadd：将操作数栈中的数据相加
    8. istore_3：从操作数栈顶将数据弹出，存入局部变量表的slot 3
    9. getstatic #4
      在这里插入图片描述
    10. iload_3
    11. invokevirtual #5：找到常量池 #5 项，定位到方法区java/io/PrintStream.println:(I)V方法，生成新的栈帧（分配locals、stack等），传递参数，执行新栈帧中的字节码
      在这里插入图片描述
    12. 执行完毕，弹出栈帧
    13. 清除main操作数栈的内容

加载和存储指令

  • 将一个局部变量加载到操作栈：iload、iload_<n>、lload、lload_<n>、fload、fload_<n>、dload、dload_<n>、aload、aload_<n>
  • 将一个数值从操作数栈存储到局部变量表：istore、istore_<n>、lstore、lstore_<n>、fstore、fstore_<n>、dstore、dstore_<n>、astore、astore_<n>
  • 将一个常量加载到操作数栈：bipush、sipush、ldc、ldc_w、ldc2_w、aconst_null、iconst_m1、iconst_<i>、lconst_<l>、fconst_<f>、dconst_<d>
  • 扩充局部变量表的访问索引的指令：wide

运算指令

  • 加法指令：iadd、ladd、fadd、dadd
  • 减法指令：isub、lsub、fsub、dsub
  • 乘法指令：imul、lmul、fmul、dmul
  • 除法指令：idiv、ldiv、fdiv、ddiv
  • 求余指令：irem、lrem、frem、drem
  • 取反指令：ineg、lneg、fneg、dneg
  • 位移指令：ishl、ishr、iushr、lshl、lshr、lushr
  • 按位或指令：ior、lor
  • 按位与指令：iand、land
  • 按位异或指令：ixor、lxor
  • 局部变量自增指令：iinc
  • 比较指令：dcmpg、dcmpl、fcmpg、fcmpl、lcmp

对象创建与访问指令

  • 创建类实例的指令：new
  • 创建数组的指令：newarray、anewarray、multianewarray
  • 访问类字段（static字段，或者称为类变量）和实例字段（非static字段，或者称为实例变量）的指令：getfield、putfield、getstatic、putstatic
  • 把一个数组元素加载到操作数栈的指令：baload、caload、saload、iaload、laload、faload、daload、aaload
  • 将一个操作数栈的值储存到数组元素中的指令：bastore、castore、sastore、iastore、fastore、dastore、aastore
  • 取数组长度的指令：arraylength
  • 检查类实例类型的指令：instanceof、checkcast

操作数栈管理指令

  • 将操作数栈的栈顶一个或两个元素出栈：pop、pop2
  • 复制栈顶一个或两个数值并将复制值或双份的复制值重新压入栈顶：dup、dup2、dup_x1、dup2_x1、dup_x2、dup2_x2
  • 将栈最顶端的两个数值互换：swap

控制转移指令

  • 条件分支：ifeq、iflt、ifle、ifne、ifgt、ifge、ifnull、ifnonnull、if_icmpeq、if_icmpne、if_icmplt、if_icmpgt、if_icmple、if_icmpge、if_acmpeq和if_acmpne
  • 复合条件分支：tableswitch、lookupswitch
  • 无条件分支：goto、goto_w、jsr、jsr_w、ret

方法调用和返回指令

  • invokevirtual指令：用于调用对象的实例方法，根据对象的实际类型进行分派（虚方法分派），这也是Java语言中最常见的方法分派方式。
  • invokeinterface指令：用于调用接口方法，它会在运行时搜索一个实现了这个接口方法的对象，找出适合的方法进行调用。
  • invokespecial指令：用于调用一些需要特殊处理的实例方法，包括实例初始化方法、私有方法和父类方法。
  • invokestatic指令：用于调用类静态方法（static方法）。
  • invokedynamic指令：用于在运行时动态解析出调用点限定符所引用的方法。并执行该方法。前面四条调用指令的分派逻辑都固化在Java虚拟机内部，用户无法改变，而invokedynamic指令的分派逻辑是由用户所设定的引导方法决定的。

二、语法糖

默认构造器

public class Candy1 {
}

编译成class文件后的代码：

public class Candy1 {
// 这个无参构造是编译器帮助我们加上的
	public Candy1() {
		super(); // 即调用父类 Object 的无参构造方法，即调用 java/lang/Object."<init>":()V
	}
}

自动装拆箱

public class Candy2 {
	public static void main(String[] args) {
		Integer x = 1;
		int y = x;
	}
}

该特性事在JDK 5 后加入的，工作原理如下：

public class Candy2 {
	public static void main(String[] args) {
		Integer x = Integer.valueOf(1);
		int y = x.intValue();
	}
}

泛型擦除

Java在编译后会执行泛型擦除动作，实际类型都被当成Object类型处理，因此在取值时，就需要额外进行类型转换操作

public class Candy3 {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<>();
		list.add(10); // 实际调用的是 List.add(Object e)
		Integer x = list.get(0); // 实际调用的是 Object obj = List.get(int index);
	}
}

// 类型转换 需要将 Object 转为 Integer
Integer x = (Integer)list.get(0);

//如果x是int类型，则需要进行拆箱操作
int x = ((Integer)list.get(0)).invalue();

可变参数

public class Candy4 {
	public static void foo(String... args) {
		String[] array = args; // 直接赋值
		System.out.println(array);
	}
	public static void main(String[] args) {
		foo("hello", "world");
	}
}

在编译期间，可变参数会转换成一个数组

public class Candy4 {
public static void foo(String[] args) {
	String[] array = args; // 直接赋值
		System.out.println(array);
	}
	public static void main(String[] args) {
		foo(new String[]{"hello", "world"});
	}
}

foreach循环

  • 普通foreach循环
    public class Candy5_1 {
	public static void main(String[] args) {
		int[] array = {1, 2, 3, 4, 5}; // 数组赋初值的简化写法也是语法糖哦
		for (int e : array) {
			System.out.println(e);
		}
	}
}

    public class Candy5_1 {
	public Candy5_1() {
	}
	public static void main(String[] args) {
		int[] array = new int[]{1, 2, 3, 4, 5};
		for(int i = 0; i < array.length; ++i) {
			int e = array[i];
			System.out.println(e);
		}
	}
}
  • 集合
    public class Candy5_2 {
	public static void main(String[] args) {
		List<Integer> list = Arrays.asList(1,2,3,4,5);
		for (Integer i : list) {
			System.out.println(i);
		}
	}
}

    public class Candy5_2 {
	public Candy5_2() {
	}
	public static void main(String[] args) {
		List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
		Iterator iter = list.iterator();
		while(iter.hasNext()) {
			Integer e = (Integer)iter.next();
			System.out.println(e);
		}
	}
}

switch字符串

public class Candy6_1 {
	public static void choose(String str) {
		switch (str) {
			case "hello": {
				System.out.println("h");
				break;
			}
			case "world": {
				System.out.println("w");
				break;
			}
		}
	}
}

编译时，会进行两重校验，对需要case的内容转换成hashcode，进行比较；而进行equals时，是为了防止hashcode冲突

public class Candy6_1 {
	public Candy6_1() {
	}
	public static void choose(String str) {
		byte x = -1;
		switch(str.hashCode()) {
		case 99162322: // hello 的 hashCode
			if (str.equals("hello")) {
				x = 0;
			}
			break;
		case 113318802: // world 的 hashCode
			if (str.equals("world")) {
				x = 1;
			}
		}
		switch(x) {
		case 0:
			System.out.println("h");
			break;
		case 1:
			System.out.println("w");
		}
	}
}

匿名内部类

public class Candy11 {
	public static void test(final int x) {
		Runnable runnable = new Runnable() {
			@Override
			public void run() {
				System.out.println("ok:" + x);
			}
		};
	}
}

编译后会额外生成一个类

// 额外生成的类
final class Candy11$1 implements Runnable {
	int val$x;
	Candy11$1(int x) {
		this.val$x = x;
	}
	public void run() {
		System.out.println("ok:" + this.val$x);
	}
}

public class Candy11 {
	public static void test(final int x){
		Runnable runnable = new Candy11$1(x);
	}
}

三、类加载

在这里插入图片描述

  • 加载：
    1. 通过一个类的全限定名来获取定义此类的二进制字节流
    2. 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
    3. 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口
  • 验证：确保Class文件的字节流中包含的信息符合规范
    1. 文件格式验证：验证字节流是否符合Class文件格式的规范，并且能被当前版本的虚拟机处理
    2. 元数据验证：对字节码描述的信息进行语义分析
    3. 字节码验证：通过数据流分析和控制流分析，确定程序语义是合法的、符合逻辑的
    4. 符号引用验证：对类自身以外（常量池中的各种符号引用）的各类信息进行匹配性校验
  • 准备：正式为类中定义的变量（即静态变量，被static修饰的变量）分配内存并设置类变量初始值
    1. 这些变量所使用的内存都应当在方法区中进行分配
    2. 进行内存分配的仅包括类变量，而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在Java堆中
  • 解析：Java虚拟机将常量池内的符号引用替换为直接引用的过程
    1. 类或者接口的解析
    2. 字段解析
    3. 方法解析
    4. 接口方法解析
  • 初始化：初始化阶段就是执行类构造器<clinit>()方法的过程
    1. <clinit>()方法是由编译器自动收集类中所有的类变量的赋值动作和静态语句块中的语句合并产生
    2. <clinit>()不需要显式地调用父类构造器，Java虚拟机会确保父类<clinit>()在子类<clinit>()之前执行
    class A {
	static int a = 0;
	static {
		System.out.println("a init");
	}
}
class B extends A {
	final static double b = 5.0;
	static boolean c = false;
	static {
		System.out.println("b init");
	}
}

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

四、类加载器

双亲委派模型

在这里插入图片描述

  • 如果一个类加载器收到了类加载的请求，它首先将请求委派给父类加载器去完成，因此所有的加载请求最终都应该传送到最顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求（它的搜索范围中没有找到所需的类）时，子加载器才会尝试自己去完成加载。
那股哇
关注
专栏目录
java byte转int 互相转换原理详解
wojiuai2093的专栏
03-02 1万+
java byte转int 互相转换原理详解 原码,反码,补码概念
JVM（三）类加载、字节码技术
haponchang的博客
05-24 856
目录 字节码技术 字节码技术应用场景 字节技术优势 常见的字节码操作类库 BCEL ASM CGLB javassist 类加载器 类加载的机制的层次结构 步骤一、类加载机制 步骤二、连接过程 步骤三、初始化 类加载器的层次结构 启动（Bootstrap）类加载器 扩展（Extension）类加载器 系统（System）类加载器、 理解双亲委派模式 双亲委派模...
字节数组和int型的相互转换
weixin_44655383的博客
04-08 1043
java.net.SocketException: Connection reset at java.net.SocketInputStream.read(Unknown Source) at java.net.SocketInputStream.read(Unknown Source) at java.net.SocketInputStream.read(Unknown Source) at com.test.Server.main(Server.java:21)
字节数组与int类型之间的转换
小` pi孩
12-01 1437
int占4个字节，一个字节8位 java中的byte是有符号的，范围是-128~127 将int转换为长度为4的字节数组 import java.util.Arrays; import java.util.Scanner; public class IntConversionByte { public static byte[] conversion(int n){ byte[] a = new byte[4]; for(int i = 0; i < 4; i+
Java 字节数组(byte[])和整型(int)的相互转换
热门推荐
Little_ant_的博客
03-08 2万+
Java 字节数组(byte[])和整型(int)的相互转换
java 字节数组转int
weixin_30922589的博客
05-17 165
4字节数组转int类型 小端模式 /** * 数组转int类型 * * @param src * @return */ public static int bytesToInt(byte[] src) { int offset = 0; int value; value...
jvm加载字节码过程
bpk_2的博客
10-20 607
前面提到，java代码编译成字节码后，由jvm加载并执行，那么jvm加载的过程是由类加载子系统来执行的。java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验，转换解析和初始化，最后形成可以被虚拟机直接使用的java类型，这个过程被称为虚拟机的类加载机制。 加载过程 类从被加载到内存到卸出内存，分为以下几个过程 加载 连接 验证 准备 解析 初始化 使用 卸载 1.加载 这里的加载指的是加载过程中把字节码从文件中的结构加载到内存中的数据结构的一步，而不是完整的加载过程。这个是运
jvm 调优笔记-jvm.zip
最新发布
11-06
Java虚拟机（JVM）是Java编程语言的核心组成部分，它负责执行字节码，管理内存，以及优化程序性能。JVM调优是提高Java应用程序性能的关键步骤，涉及到多个方面，包括堆内存设置、垃圾收集器选择、类加载机制、线程...
jvm字节码与类的加载.xmind
11-15
自己总结的jvm中字节码与类的加载的笔记，绘制了详细的思维导图，每个思维导图中均有详细的博文解释，方便大家学习和理解，免费分享给大家。适合jvm的爱好者和学习者
JVM学习笔记-第八章-虚拟机字节码执行引擎
qq_47815451的博客
08-19 133
JVM学习笔记-第八章-虚拟机字节码执行引擎 8.1 概述 在《Java虚拟机规范》中制定了Java虚拟机字节码执行引擎的概念模型，在不同的虚拟机实现中，执行引擎在执行字节码的时候，通常会有解释执行（通过解释器执行）和编译执行（通过即时编译器产生本地代码执行）两种选择，也可能两者兼备等。 但从外观上来看，所有的Java虚拟机的执行引擎输入、输出都是一致的：输入的是字节码二进制流，处理过程是字节码解析执行的等效过程，输出的是执行结果，本章将主要从概念模型的角度来讲解虚拟机的方法调用和字节码执行。 8.2 运
byte数组转换工具类 byte数组转int，byte数组转short，short转byte数组
09-19
byte数组操作的工具类，支持byte数组转int，int转byte数组，byte数组转short，short转byte数组。。。 下载的人多了，csdn会自动涨分，现在可以手动调了，我给降到最低了
基于java中byte数组与int类型的转换(两种方法)
09-01
下面小编就为大家带来一篇基于java中byte数组与int类型的转换(两种方法)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
int类型和byte数组之间的转换
10-11
写一个方法，将int类型转换为字节数组，输入任意int类型整型，输出字节数组；写第二个方法，输入字节数组，输出对应int类型数据。
JVM笔记：Java虚拟机的字节码指令详解
verzqli的博客
10-29 1025
1.字节码 Java能发展到现在，其“一次编译，多处运行”的功能功不可没，这里最主要的功劳就是JVM和字节码了，在不同平台和操作系统上根据JVM规范的定制JVM可以运行相同字节码（.Class文件），并得到相同的结果。之所以被称之为字节码，是因为字节码文件由十六进制值组成，而JVM以两个十六进制值为一组，即以字节为单位进行读取。在Java中一般是用javac命令编译源代码为字节码文件，将java...
JVM学习笔记-第六章-类文件结构
qq_47815451的博客
08-16 131
JVM学习笔记-第六章-类文件结构 6.3 Class类文件的结构 本章中，笔者只是通俗地将任意一个有效的类或接口锁应当满足的格式称为“Class文件格式”，实际上它完全不需要以磁盘的形式存在。 Class文件是一组以8个字节为基础单位的二进制流，各个数据项目严格按照顺序紧凑地排列在文件之中，中间没有添加任何分隔符，这使得整个Class文件中存储的内容几乎全都是程序运行的必要数据。当遇到需要占用8个字节以上空间的数据项时，则会按照高位在前的方式分割成若干个8个字节进行存储。Class文件格式采用一种类似于C
byte数组转化为int数组
ZaneZhu的专栏
05-25 1153
/// /// byte数组转int数组 /// /// /// public static int[] ByteToIntArray(byte[] btArray) { if (btArray.Length % 4 != 0 && btArray.Length > 0)
byte[]数组和int之间的转换
feiyingzaishi的博客
10-16 3368
转载自：https://www.cnblogs.com/lizhenlin/p/6807856.html 这里简单记录下两种转换方式： 第一种： 1、int与byte[]之间的转换（类似的byte short,long型）   [java] view plain copy   /**       * 将int数值转换为占四个字节的byte数组，本方法适用于(低位在前，高位在后)的顺...
int转byte[],byte[]转int
jackle_liu
01-31 164
    public byte[] intToByte(int i) {         byte[] abyte0 = new byte[4];         abyte0[0] = (byte) (0xff &amp; i);         abyte0[1] = (byte) ((0xff00 &amp; i) &gt;&gt; 8);         abyte0[2] = (byte...
字节数组与int相互转换
MarkHome
05-05 697
package Util; /** *数据工具类 */ public class DataUtil { //工具类的方法是静态的 public static byte [] int2bytes(int i){ byte [] bytes = new byte[4]; bytes[0] = (byte)(i >>0) ; ...
JVM入门笔记：理解JVM架构与类加载机制
加载阶段涉及构建Class对象，链接阶段包括验证（检查字节码的正确性）和准备（为类变量分配内存）。此外，执行引擎的JIT编译器对热点数据进行优化，提高程序性能，而解释器则逐行解释字节码，确保程序实时响应。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值