关于java:Java-进阶-02-是时候了解一下-Java-字节码了

119次阅读

共计 6533 个字符，预计需要花费 17 分钟才能阅读完成。

什么是字节码？

  • 咱们平时所说的 Java 字节码，指的是用 Java 语言编译成的字节码。精确的说能在 JVM 平台上执行的字节码格局都是一样的。所以应该统称为 JVM 字节码。
  • 不同的编译器，能够编译出雷同的字节码文件，字节码文件也能够在不同的 JVM 上运行。
  • Java 虚拟机与 Java 语言并没有必然的分割，它只与特定的二进制文件格式 .class 文件格式所关联，.class 文件中蕴含了 Java 虚拟机指令集（或者称为字节码、Bytecodes）和符号表，还有一些其余的辅助信息。
  • Java bytecode 由单字节（byte）的指令组成，实践上最多反对 256 个操作码（opcode）。实际上 Java 只应用了 200 左右的操作码，还有一些操作码则保留给调试操作。详情见：
  • JVM 指令集对照表

依据指令的性质，次要分为四个大类：

  1. 栈操作指令，包含与局部变量交互的指令
  2. 程序流程控制指令
  3. 对象操作指令，包含办法调用指令
  4. 算术运算以及类型转换指令

举个简略的例子：

public class HelloByteCode {public static void main(String[] args) {HelloByteCode obj = new HelloByteCode();
    }
}
$ javac -g HelloByteCode.java
$ javap -c -v HelloByteCode
Classfile /Users/yonghong/Coding/code-lab/gtu-java/week01/HelloByteCode.class
  Last modified 2021-1-7; size 415 bytes
  MD5 checksum 44dd68d97fffda0bd16a524fb32b983a
  Compiled from "HelloByteCode.java"
public class HelloByteCode
  minor version: 0
  major version: 52   // 52 对应 Java 8
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:        // 常量池
   #1 = Methodref          #4.#19         // java/lang/Object."<init>":()V
   #2 = Class              #20            // HelloByteCode
   #3 = Methodref          #2.#19         // HelloByteCode."<init>":()V
   #4 = Class              #21            // java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Utf8               Code
   #8 = Utf8               LineNumberTable
   #9 = Utf8               LocalVariableTable
  #10 = Utf8               this
  #11 = Utf8               LHelloByteCode;
  #12 = Utf8               main
  #13 = Utf8               ([Ljava/lang/String;)V
  #14 = Utf8               args
  #15 = Utf8               [Ljava/lang/String;
  #16 = Utf8               obj
  #17 = Utf8               SourceFile
  #18 = Utf8               HelloByteCode.java
  #19 = NameAndType        #5:#6          // "<init>":()V
  #20 = Utf8               HelloByteCode
  #21 = Utf8               java/lang/Object
{public HelloByteCode();
    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 1: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   LHelloByteCode;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: new           #2                  // class HelloByteCode
         3: dup
         4: invokespecial #3                  // Method "<init>":()V
         7: astore_1
         8: return
      LineNumberTable:
        line 3: 0   // new 指令在源码的第 3 行
        line 4: 8   // return 指令在源码的第 4 行
      LocalVariableTable:   // 本地变量表
        Start  Length  Slot  Name   Signature
      // 起作用的行  失效范畴  槽数  变量名称  变量类型签名
            0       9     0  args   [Ljava/lang/String;
            8       1     1   obj   LHelloByteCode;
}
SourceFile: "HelloByteCode.java"

javac 与 javap

javac 的用法 

$ javac -help
用法: javac <options> <source files>
其中, 可能的选项包含:
  -g                         生成所有调试信息
  -g:none                    不生成任何调试信息
  -g:{lines,vars,source}     只生成某些调试信息
  -nowarn                    不生成任何正告
  -verbose                   输入无关编译器正在执行的操作的音讯
  -deprecation               输入应用已过期的 API 的源地位
  -classpath < 门路 >            指定查找用户类文件和正文处理程序的地位
  -cp < 门路 >                   指定查找用户类文件和正文处理程序的地位
  -sourcepath < 门路 >           指定查找输出源文件的地位
  -bootclasspath < 门路 >        笼罩疏导类文件的地位
  -extdirs < 目录 >              笼罩所装置扩大的地位
  -endorseddirs < 目录 >         笼罩签名的规范门路的地位
  -proc:{none,only}          管制是否执行正文解决和 / 或编译。-processor <class1>[,<class2>,<class3>...] 要运行的正文处理程序的名称; 绕过默认的搜寻过程
  -processorpath < 门路 >        指定查找正文处理程序的地位
  -parameters                生成元数据以用于办法参数的反射
  -d < 目录 >                    指定搁置生成的类文件的地位
  -s < 目录 >                    指定搁置生成的源文件的地位
  -h < 目录 >                    指定搁置生成的本机标头文件的地位
  -implicit:{none,class}     指定是否为隐式援用文件生成类文件
  -encoding < 编码 >             指定源文件应用的字符编码
  -source < 发行版 >              提供与指定发行版的源兼容性
  -target < 发行版 >              生成特定 VM 版本的类文件
  -profile < 配置文件 >            请确保应用的 API 在指定的配置文件中可用
  -version                   版本信息
  -help                      输入规范选项的提要
  - A 关键字 [= 值]                  传递给正文处理程序的选项
  -X                         输入非标准选项的提要
  -J< 标记 >                     间接将 < 标记 > 传递给运行时零碎
  -Werror                    呈现正告时终止编译
  @< 文件名 >                     从文件读取选项和文件名

javap 的用法 

$ javap -help
用法: javap <options> <classes>
其中, 可能的选项包含:
  -help  --help  -?        输入此用法音讯
  -version                 版本信息
  -v  -verbose             输入附加信息
  -l                       输入行号和本地变量表
  -public                  仅显示公共类和成员
  -protected               显示受爱护的 / 公共类和成员
  -package                 显示程序包 / 受爱护的 / 公共类
                           和成员 (默认)
  -p  -private             显示所有类和成员
  -c                       对代码进行反汇编
  -s                       输入外部类型签名
  -sysinfo                 显示正在解决的类的
                           零碎信息 (门路, 大小, 日期, MD5 散列)
  -constants               显示最终常量
  -classpath <path>        指定查找用户类文件的地位
  -cp <path>               指定查找用户类文件的地位
  -bootclasspath <path>    笼罩疏导类文件的地位

字节码的运行时构造

JVM 是一台基于栈的计算机器。

每个线程都有一个独属于本人的线程栈（JVM Stack），用于存储 栈帧（Frame）。每一次办法调用，JVM 都会主动创立一个栈帧。栈帧由操作数栈，局部变量数组以及一个 Class 援用组成。Class 援用指向以后办法在运行时常量池中对应的 Class。

从助记符到二进制

四则运行的例子

MovingAverage.java

public class MovingAverage {
    private int count = 0;
    private double sum = 0.0D;

    public void submit(double value) {
        this.count++;
        this.sum += value;
    }

    public double getAvg() {if (0 == this.count) {return sum;}
        return this.sum / this.count;
    }
}

LocalVaribleTest.java

public class LocalVaribleTest {public static void main(String[] args) {MovingAverage ma = new MovingAverage();
        int num1 = 1;
        int num2 = 2;
        ma.submit(num1);
        ma.submit(num2);
        double avg = ma.getAvg();}
}
$ javap -c MovingAverage
Compiled from "MovingAverage.java"
public class MovingAverage {public MovingAverage();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: iconst_0
       6: putfield      #2                  // Field count:I
       9: aload_0
      10: dconst_0
      11: putfield      #3                  // Field sum:D
      14: return

  public void submit(double);
    Code:
       0: aload_0
       1: dup
       2: getfield      #2                  // Field count:I
       5: iconst_1
       6: iadd
       7: putfield      #2                  // Field count:I
      10: aload_0
      11: dup
      12: getfield      #3                  // Field sum:D
      15: dload_1
      16: dadd
      17: putfield      #3                  // Field sum:D
      20: return

  public double getAvg();
    Code:
       0: iconst_0
       1: aload_0
       2: getfield      #2                  // Field count:I
       5: if_icmpne     13
       8: aload_0
       9: getfield      #3                  // Field sum:D
      12: dreturn
      13: aload_0
      14: getfield      #3                  // Field sum:D
      17: aload_0
      18: getfield      #2                  // Field count:I
      21: i2d
      22: ddiv
      23: dreturn
}

$ javap -c LocalVaribleTest
Compiled from "LocalVaribleTest.java"
public class LocalVaribleTest {public LocalVaribleTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class MovingAverage
       3: dup
       4: invokespecial #3                  // Method MovingAverage."<init>":()V
       7: astore_1
       8: iconst_1
       9: istore_2
      10: iconst_2
      11: istore_3
      12: aload_1
      13: iload_2
      14: i2d   // int 转成 double 隐式转换
      15: invokevirtual #4                  // Method MovingAverage.submit:(D)V
      18: aload_1
      19: iload_3
      20: i2d
      21: invokevirtual #4                  // Method MovingAverage.submit:(D)V
      24: aload_1
      25: invokevirtual #5                  // Method MovingAverage.getAvg:()D
      28: dstore        4
      30: return
}

算数操作与类型转换

一个残缺的循环管制 

public class ForLoopTest {private static int[] nums = {1, 6, 8};
    public static void main(String[] args) {MovingAverage ma = new MovingAverage();
        for (int num : nums) {ma.submit(num);
        }
        double avg = ma.getAvg();}
}
$ javap -c ForLoopTest
Compiled from "ForLoopTest.java"
public class ForLoopTest {public ForLoopTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class MovingAverage
       3: dup
       4: invokespecial #3                  // Method MovingAverage."<init>":()V
       7: astore_1
       8: getstatic     #4                  // Field nums:[I
      11: astore_2
      12: aload_2
      13: arraylength
      14: istore_3
      15: iconst_0                // 初始化变量 0
      16: istore        4         // 存储到本地变量表 4 槽位
      18: iload         4         // 加载 4 槽位 到操作数栈
      20: iload_3                 // 加载 int 3 到操作数栈
      21: if_icmpge     43        // 比拟，如果大于等于跳转到 43 行指令
      24: aload_2
      25: iload         4
      27: iaload
      28: istore        5
      30: aload_1
      31: iload         5
      33: i2d
      34: invokevirtual #5                  // Method MovingAverage.submit:(D)V
      37: iinc          4, 1      // 4 槽位上加 1
      40: goto          18        // goto 18 行指令
      43: aload_1
      44: invokevirtual #6                  // Method MovingAverage.getAvg:()D
      47: dstore_2
      48: return

  static {};
    Code:
       0: iconst_3
       1: newarray       int
       3: dup
       4: iconst_0
       5: iconst_1
       6: iastore
       7: dup
       8: iconst_1
       9: bipush        6
      11: iastore
      12: dup
      13: iconst_2
      14: bipush        8
      16: iastore
      17: putstatic     #4                  // Field nums:[I
      20: return
}

办法调用的指令

  • invokestatic，顾名思义，这个指令用于调用某个类的静态方法，这是办法调用指令中最快的一个。
  • invokespecial, 用来调用构造函数，但也能够用于调用同一个类中的 private 办法, 以及可见的超类办法。
  • invokevirtual，如果是具体类型的指标对象，invokevirtual 用于调用公共，受爱护和 package 级的公有办法。
  • invokeinterface，当通过接口援用来调用办法时，将会编译为 invokeinterface 指令。
  • invokedynamic，JDK7 新减少的指令，是实现“动静类型语言”（Dynamically Typed Language）反对而进行的降级改良，同时也是 JDK8 当前反对 lambda 表达式的实现根底。

正文完
java
发表至： java
2021-05-14
 0
关于java:JavaSE第16篇集合之Collection集合下篇
Java安全验证之JWT实践
关于java:我在上海乐字节学习java的第十一天持续更新中
关于java:实践总结在-Java-中调用-Go-代码