JVM

1.引言

1.1 什么是JVM

  • 定义： Java Virtual Machine - java 程序的运行环境（java 二进制字节码的运行环境）
  • 好处： 一次编写，到处运行 自动内存管理，垃圾回收功能 数组下标越界检查 多态
  • 比较： jvm jre jdk

1.2 学习 JVM 有什么用 ?

  • 面试
  • 理解底层的实现原理
  • 中高级程序员的必备技能

1.3 常见的 JVM

1.4. 学习路线

参考资料

2.内存结构

2.1 程序计数器

2.1.1定义

Program Counter Register 程序计数器（寄存器）

  • 作用：是记住下一条jvm指令的执行地址
  • 特点：是线程私有的 不会存在内存溢出
  • 每一个线程都有自己的程序计数器

2.1.2作用

0: getstatic #20 // PrintStream out = System.out;
3: astore_1 // --
4: aload_1 // out.println(1);
5: iconst_1 // --
6: invokevirtual #26 // --
9: aload_1 // out.println(2);
10: iconst_2 // --
11: invokevirtual #26 // --
14: aload_1 // out.println(3);
15: iconst_3 // --
16: invokevirtual #26 // --
19: aload_1 // out.println(4);
20: iconst_4 // --
21: invokevirtual #26 // --
24: aload_1 // out.println(5);
25: iconst_5 // --
26: invokevirtual #26 // --
29: return

2.2 虚拟机栈

2.2.1 定义

Java Virtual Machine Stacks （Java 虚拟机栈）

  • 每个线程运行时所需要的内存，称为虚拟机栈
  • 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
  • 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

问题辨析

1.垃圾回收是否涉及栈内存？

  • 不会，方法调用结束后会自动弹出栈，不需要垃圾回收，垃圾回收的是对象

2.栈内存分配越大越好吗？

  • 不是，物理内存有限，栈内存分配越大线程越少，过大栈内存只是可以多几次递归调用

3.方法内的局部变量是否线程安全？

  • 如果方法内局部变量没有逃离方法的作用访问，它是线程安全的
  • 如果是局部变量引用了对象，并逃离方法的作用范围，需要考虑线程安全

2.2.2 栈内存溢出

  • 栈帧过多导致栈内存溢出
  • 栈帧过大导致栈内存溢出

2.2.3 线程运行诊断

  • 案例1： cpu 占用过多

  • 定位

    • 用top定位哪个进程对cpu的占用过高
    • ps H -eo pid,tid,%cpu | grep 进程id （用ps命令进一步定位是哪个线程引起的cpu占用过高）
    • jstack 进程id
      • 可以根据线程id 找到有问题的线程，进一步定位到问题代码的源码行号

  • 案例2：程序运行很长时间没有结果

2.3 本地方法栈

2.4 堆

2.4.1 定义

  • Heap 堆 通

    • 过 new 关键字，创建对象都会使用堆内存

  • 特点

    • 它是线程共享的，堆中对象都需要考虑线程安全的问题 有垃圾回收机制

2.4.2 堆内存溢出

2.4.3 堆内存诊断

  • 1.jps 工具

    • 查看当前系统中有哪些 java 进程

  • 2.jmap 工具

    • 查看堆内存占用情况 jmap - heap 进程id

  • 3.jconsole 工具

    • 图形界面的，多功能的监测工具，可以连续监测 案例 垃圾回收后，内存占用仍然很高

  • 案例

    • 垃圾回收后，内存占用仍然很高

2.5 方法区

2.5.1 定义

JVM规范-方法区定义

2.5.2 组成

2.5.3 方法区内存溢出

1.8 以前会导致永久代内存溢出

* 演示永久代内存溢出 java.lang.OutOfMemoryError: PermGen space
* -XX:MaxPermSize=8m

1.8 之后会导致元空间内存溢出

* 演示元空间内存溢出 java.lang.OutOfMemoryError: Metaspace
* -XX:MaxMetaspaceSize=8m

场景

spring
  • mybatis

2.5.4 运行时常量池

  • 常量池，就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量 等信息
  • 运行时常量池，常量池是 *.class 文件中的，当该类被加载，它的常量池信息就会放入运行时常量 池，并把里面的符号地址变为真实地址

1.StringTable

先看几道面试题：

String s1 = "a";
String s2 = "b";
String s3 = "a" + "b";
String s4 = s1 + s2;
String s5 = "ab";
String s6 = s4.intern();
// 问
System.out.println(s3 == s4);
System.out.println(s3 == s5);
System.out.println(s3 == s6);
String x2 = new String("c") + new String("d");
String x1 = "cd";
x2.intern();
// 问，如果调换了【最后两行代码】的位置呢，如果是jdk1.6呢
System.out.println(x1 == x2);

2.StringTable 特性

  • 常量池中的字符串仅是符号，第一次用到时才变为对象
  • 利用串池的机制，来避免重复创建字符串对象
  • 字符串变量拼接的原理是 StringBuilder （1.8）
  • 字符串常量拼接的原理是编译期优化
  • 可以使用 intern 方法，主动将串池中还没有的字符串对象放入串池
    • 1.8 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串 池中的对象返回
    • 1.6 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有会把此对象复制一份， 放入串池， 会把串池中的对象返回

3.StringTable 位置

4.StringTable 垃圾回收

5.StringTable 性能调优

  • 调整 -XX:StringTableSize=桶个数
  • 考虑将字符串对象是否入池

2.6 直接内存

2.6.1 定义

Direct Memory

  • 常见于 NIO 操作时，用于数据缓冲区
  • 分配回收成本较高，但读写性能高
  • 不受 JVM 内存回收管理

2.6.2 分配和回收原理

  • 使用了 Unsafe 对象完成直接内存的分配回收，并且回收需要主动调用 freeMemory 方法
  • ByteBuffer 的实现类内部，使用了 Cleaner （虚引用）来监测 ByteBuffer 对象，一旦 ByteBuffer 对象被垃圾回收，那么就会由 ReferenceHandler 线程通过 Cleaner 的 clean 方法调 用 freeMemory 来释放直接内存

3.垃圾回收

3.1 如何判断对象可以回收

3.1.1 引用计数法

3.1.2 可达性分析算法

  • Java 虚拟机中的垃圾回收器采用可达性分析来探索所有存活的对象
  • 扫描堆中的对象，看是否能够沿着 GC Root对象 为起点的引用链找到该对象，找不到，表示可以回收
  • 哪些对象可以作为 GC Root ?

3.1.3 四种引用

1.强引用

  • 只有所有 GC Roots 对象都不通过【强引用】引用该对象，该对象才能被垃圾回收

2.软引用（SoftReference）

  • 仅有软引用引用该对象时，在垃圾回收后，内存仍不足时会再次出发垃圾回收，回收软引用对象
  • 可以配合引用队列来释放软引用自身

3.弱引用（WeakReference）

  • 仅有弱引用引用该对象时，在垃圾回收时，无论内存是否充足，都会回收弱引用对象
  • 可以配合引用队列来释放弱引用自身

4.虚引用（PhantomReference）

  • 必须配合引用队列使用，主要配合 ByteBuffer 使用，被引用对象回收时，会将虚引用入队， 由 Reference Handler 线程调用虚引用相关方法释放直接内存

5.终结器引用（FinalReference）

  • 无需手动编码，但其内部配合引用队列使用，在垃圾回收时，终结器引用入队（被引用对象 暂时没有被回收），再由 Finalizer 线程通过终结器引用找到被引用对象并调用它的 finalize 方法，第二次 GC 时才能回收被引用对象

3.2 垃圾回收算法

3.2.1 标记清除

定义： Mark Sweep

  • 速度较快
  • 会造成内存碎片

3.2.2 标记整理

定义：Mark Compact

  • 速度慢
  • 没有内存碎片

3.2.3 复制

定义：Copy

  • 不会有内存碎片
  • 需要占用双倍内存空间

3.3 分代垃圾回收

  • 对象首先分配在伊甸园区域
  • 新生代空间不足时，触发 minor gc，伊甸园和 from 存活的对象使用 copy 复制到 to 中，存活的 对象年龄加 1并且交换 from to
  • minor gc 会引发 stop the world，暂停其它用户的线程，等垃圾回收结束，用户线程才恢复运行
  • 当对象寿命超过阈值时，会晋升至老年代，最大寿命是15（4bit）
  • 当老年代空间不足，会先尝试触发 minor gc，如果之后空间仍不足，那么触发 full gc，STW的时 间更长

3.3.1 相关 VM 参数

含义 参数
堆初始大小 -Xms
堆最大大小 -Xmx 或 -XX:MaxHeapSize=size
新生代大小 -Xmn 或 (-XX:NewSize=size + -XX:MaxNewSize=size )
幸存区比例（动态） -XX:InitialSurvivorRatio=ratio 和 -XX:+UseAdaptiveSizePolicy
幸存区比例 -XX:SurvivorRatio=ratio
晋升阈值 -XX:MaxTenuringThreshold=threshold
晋升详情 -XX:+PrintTenuringDistribution
GC详情 -XX:+PrintGCDetails -verbose:gc
FullGC前MinorGC -XX:+ScavengeBeforeFullGC

3.4 垃圾回收器

1.串行

  • 单线程

  • 堆内存较小，适合个人电脑

2.吞吐量优先

  • 多线程
  • 堆内存较大，多核 cpu
  • 让单位时间内，STW 的时间最短 0.2 0.2 = 0.4，垃圾回收时间占比最低，这样就称吞吐量高

3.响应时间优先

  • 多线程
  • 堆内存较大，多核 cpu
  • 尽可能让单次 STW 的时间最短 0.1 0.1 0.1 0.1 0.1 = 0.5

3.4.1 串行

-XX:+UseSerialGC = Serial + SerialOld

3.4.2 吞吐量优先

XX:+UseParallelGC ~ -XX:+UseParallelOldGC
-XX:+UseAdaptiveSizePolicy
-XX:GCTimeRatio=ratio
-XX:MaxGCPauseMillis=ms
-XX:ParallelGCThreads=n

3.4.3 响应时间优先

-XX:+UseConcMarkSweepGC ~ -XX:+UseParNewGC ~ SerialOld
-XX:ParallelGCThreads=n ~ -XX:ConcGCThreads=threads
-XX:CMSInitiatingOccupancyFraction=percent
-XX:+CMSScavengeBeforeRemark

3.4.4 G1

定义：Garbage First

  • 2004 论文发布
  • 2009 JDK 6u14 体验
  • 2012 JDK 7u4 官方支持
  • 2017 JDK 9 默认

适用场景

  • 同时注重吞吐量（Throughput）和低延迟（Low latency），默认的暂停目标是 200 ms
  • 超大堆内存，会将堆划分为多个大小相等的 Region
  • 整体上是 标记+整理 算法，两个区域之间是 复制 算法

相关 JVM 参数

-XX:+UseG1GC
-XX:G1HeapRegionSize=size
-XX:MaxGCPauseMillis=time
  1. G1 垃圾回收阶段

  1. Young Collection
  • 会 STW

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-roosKfM3-1673928341899)(E:\桌面\课程\JAVA\JVM\pic\20.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eDkEHHl1-1673928341899)(D:/个人博客/_posts/临时/pic/21.png)]

  1. Young Collection + CM
  • 在 Young GC 时会进行 GC Root 的初始标记
  • 老年代占用堆空间比例达到阈值时，进行并发标记（不会 STW），由下面的 JVM 参数决定
-XX:InitiatingHeapOccupancyPercent=percent （默认45%）

  1. Mixed Collection

会对 E、S、O 进行全面垃圾回收

  • 最终标记（Remark）会 STW
  • 拷贝存活（Evacuation）会 STW
-XX:MaxGCPauseMillis=ms

  1. Full GC

  • SerialGC

    • 新生代内存不足发生的垃圾收集 - minor gc
    • 老年代内存不足发生的垃圾收集 - full gc

  • ParallelGC

    • 新生代内存不足发生的垃圾收集 - minor gc
    • 老年代内存不足发生的垃圾收集 - full gc

  • CMS

    • 新生代内存不足发生的垃圾收集 - minor gc
    • 老年代内存不足

  • G1

    • 新生代内存不足发生的垃圾收集 - minor gc
    • 老年代内存不足
  1. Young Collection 跨代引用
  • 新生代回收的跨代引用（老年代引用新生代）问题

  • 卡表与 Remembered Set
  • 在引用变更时通过 post-write barrier + dirty card queue
  • concurrent refinement threads 更新 Remembered Set

  1. Remark
  • pre-write barrier + satb_mark_queue

  1. JDK 8u20 字符串去重
  • 优点：节省大量内存
  • 缺点：略微多占用了 cpu 时间，新生代回收时间略微增加

-XX:+UseStringDeduplication

String s1 = new String("hello"); // char[]{'h','e','l','l','o'}
String s2 = new String("hello"); // char[]{'h','e','l','l','o'}
  • 将所有新分配的字符串放入一个队列
  • 当新生代回收时，G1并发检查是否有字符串重复
  • 如果它们值一样，让它们引用同一个 char[]
  • 注意，与 String.intern() 不一样
    • String.intern() 关注的是字符串对象
    • 而字符串去重关注的是 char[]
    • 在 JVM 内部，使用了不同的字符串表
  1. JDK 8u40 并发标记类卸载

所有对象都经过并发标记后，就能知道哪些类不再被使用，当一个类加载器的所有类都不再使用，则卸 载它所加载的所有类

-XX:+ClassUnloadingWithConcurrentMark 默认启用
  1. JDK 8u60 回收巨型对象
  • 一个对象大于 region 的一半时，称之为巨型对象
  • G1 不会对巨型对象进行拷贝
  • 回收时被优先考虑
  • G1 会跟踪老年代所有 incoming 引用，这样老年代 incoming 引用为0 的巨型对象就可以在新生 代垃圾回收时处理掉
  1. JDK 9 并发标记起始时间的调整
  • 并发标记必须在堆空间占满前完成，否则退化为 FullGC
  • JDK 9 之前需要使用 -XX:InitiatingHeapOccupancyPercent
  • JDK 9 可以动态调整
    • XX:InitiatingHeapOccupancyPercent 用来设置初始值
    • 进行数据采样并动态调整
    • 总会添加一个安全的空档空间
  1. JDK 9 更高效的回收
  • 250+增强
  • 180+bug修复
  • https://docs.oracle.com/en/java/javase/12/gctuning

3.5 垃圾回收调优

预备知识

  • 掌握 GC 相关的 VM 参数，会基本的空间调整
  • 掌握相关工具
  • 明白一点：调优跟应用、环境有关，没有放之四海而皆准的法则

3.5.1 调优领域

  • 内存
  • 锁竞争
  • cpu占用
  • io

3.5.2 确定目标

  • 【低延迟】还是【高吞吐量】，选择合适的回收器
  • CMS，G1，ZGC
  • ParallelGC
  • Zing

3.5.3 最快的 GC

答案是不发生 GC

  • 查看 FullGC 前后的内存占用，考虑下面几个问题

    • 数据是不是太多？

      • resultSet = statement.executeQuery(“select * from 大表 limit n”)
    • 数据表示是否太臃肿？
      • 对象图
      • 对象大小 16 Integer 24 int 4
    • 是否存在内存泄漏？
      • static Map map =
      • 软
      • 弱
      • 第三方缓存实现

3.5.4 新生代调优

  • 新生代的特点

    • 所有的 new 操作的内存分配非常廉价

      • TLAB thread-local allocation buffer

    • 死亡对象的回收代价是零

  • 大部分对象用过即死

    • Minor GC 的时间远远低于 Full GC

  • 越大越好吗？

-Xmn Sets the initial and maximum size (in bytes) of the heap for the young generation (nursery). GC is performed in this region more often than in other regions. If the size for the young generation is too small, then a lot of minor garbage collections are performed. If the size is too large, then only full garbage collections are performed, which can take a long time to complete. Oracle recommends that you keep the size for the young generation greater than 25% and less than 50% of the overall heap size.

  • 新生代能容纳所有【并发量 * (请求-响应)】的数据
  • 幸存区大到能保留【当前活跃对象+需要晋升对象】
  • 晋升阈值配置得当，让长时间存活对象尽快晋升

-XX:MaxTenuringThreshold=threshold

-XX:+PrintTenuringDistribution

Desired survivor size 48286924 bytes, new threshold 10 (max 10)
- age 1: 28992024 bytes, 28992024 total
- age 2: 1366864 bytes, 30358888 total
- age 3: 1425912 bytes, 31784800 total
...

3.5.5 老年代调优

以 CMS 为例

  • CMS 的老年代内存越大越好
  • 先尝试不做调优，如果没有 Full GC 那么已经…，否则先尝试调优新生代
  • 观察发生 Full GC 时老年代内存占用，将老年代内存预设调大 1/4 ~ 1/3
    • -XX:CMSInitiatingOccupancyFraction=percent

3.5.6 案例

  • 案例1 Full GC 和 Minor GC频繁
  • 案例2 请求高峰期发生 Full GC，单次暂停时间特别长 （CMS）
  • 案例3 老年代充裕情况下，发生 Full GC （CMS jdk1.7）

4.类加载与字节码技术

4.1 类文件结构

一个简单的 HelloWorld.java

package cn.wzk.jvm.t5;// HelloWorld 示例public class HelloWorld {public static void main(String[] args) {System.out.println("hello world");}}

执行 javac -parameters -d . HellowWorld.java

编译为 HelloWorld.class 后是这个样子的：

[root@localhost ~]# od -t xC HelloWorld.class
0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09
0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07
0000040 00 1c 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29
0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e
0000100 75 6d 62 65 72 54 61 62 6c 65 01 00 12 4c 6f 63
0000120 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65 01
0000140 00 04 74 68 69 73 01 00 1d 4c 63 6e 2f 69 74 63
0000160 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c 6f
0000200 57 6f 72 6c 64 3b 01 00 04 6d 61 69 6e 01 00 16
0000220 28 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72
0000240 69 6e 67 3b 29 56 01 00 04 61 72 67 73 01 00 13
0000260 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69
0000300 6e 67 3b 01 00 10 4d 65 74 68 6f 64 50 61 72 61
0000320 6d 65 74 65 72 73 01 00 0a 53 6f 75 72 63 65 46
0000340 69 6c 65 01 00 0f 48 65 6c 6c 6f 57 6f 72 6c 64
0000360 2e 6a 61 76 61 0c 00 07 00 08 07 00 1d 0c 00 1e
0000400 00 1f 01 00 0b 68 65 6c 6c 6f 20 77 6f 72 6c 64
0000420 07 00 20 0c 00 21 00 22 01 00 1b 63 6e 2f 69 74
0000440 63 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c
0000460 6f 57 6f 72 6c 64 01 00 10 6a 61 76 61 2f 6c 61
0000500 6e 67 2f 4f 62 6a 65 63 74 01 00 10 6a 61 76 61
0000520 2f 6c 61 6e 67 2f 53 79 73 74 65 6d 01 00 03 6f
0000540 75 74 01 00 15 4c 6a 61 76 61 2f 69 6f 2f 50 72
0000560 69 6e 74 53 74 72 65 61 6d 3b 01 00 13 6a 61 76
0000600 61 2f 69 6f 2f 50 72 69 6e 74 53 74 72 65 61 6d
0000620 01 00 07 70 72 69 6e 74 6c 6e 01 00 15 28 4c 6a
0000640 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b
0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01
0000700 00 07 00 08 00 01 00 09 00 00 00 2f 00 01 00 01
0000720 00 00 00 05 2a b7 00 01 b1 00 00 00 02 00 0a 00
0000740 00 00 06 00 01 00 00 00 04 00 0b 00 00 00 0c 00
0000760 01 00 00 00 05 00 0c 00 0d 00 00 00 09 00 0e 00
0001000 0f 00 02 00 09 00 00 00 37 00 02 00 01 00 00 00
0001020 09 b2 00 02 12 03 b6 00 04 b1 00 00 00 02 00 0a
0001040 00 00 00 0a 00 02 00 00 00 06 00 08 00 07 00 0b
0001060 00 00 00 0c 00 01 00 00 00 09 00 10 00 11 00 00
0001100 00 12 00 00 00 05 01 00 10 00 00 00 01 00 13 00
0001120 00 00 02 00 14

根据 JVM 规范，类文件结构如下

ClassFile {
u4 magic;
u2 minor_version;
u2 major_version;
u2 constant_pool_count;
cp_info constant_pool[constant_pool_count-1];
u2 access_flags;
u2 this_class;
u2 super_class;
u2 interfaces_count;
u2 interfaces[interfaces_count];
u2 fields_count;
field_info fields[fields_count];
u2 methods_count;
method_info methods[methods_count];
u2 attributes_count;
attribute_info attributes[attributes_count];
}

4.1.1 魔数

0~3 字节，表示它是否是【class】类型的文件

0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09

4.1.2 版本

4~7 字节，表示类的版本 00 34（52） 表示是 Java 8

0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09

4.1.3 常量池

Constant Type Value
CONSTANT_Class 7
CONSTANT_Fieldref 9
CONSTANT_Methodref 10
CONSTANT_InterfaceMethodref 11
CONSTANT_String 8
CONSTANT_Integer 3
CONSTANT_Float 4
CONSTANT_Long 5
CONSTANT_Double 6
CONSTANT_NameAndType 12
CONSTANT_Utf8 1
CONSTANT_MethodHandle 15
CONSTANT_MethodType 16
CONSTANT_InvokeDynamic 18

8~9 字节，表示常量池长度，00 23 （35） 表示常量池有 #1~#34项，注意 #0 项不计入，也没有值

0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09

第#1项 0a 表示一个 Method 信息，00 06 和 00 15（21） 表示它引用了常量池中 #6 和 #21 项来获得这个方法的【所属类】和【方法名】

0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09

第#2项 09 表示一个 Field 信息，00 16（22）和 00 17（23） 表示它引用了常量池中 #22 和 # 23 项来获得这个成员变量的【所属类】和【成员变量名】

0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09

0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07

第#3项 08 表示一个字符串常量名称，00 18（24）表示它引用了常量池中 #24 项

0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07

第#4项 0a 表示一个 Method 信息，00 19（25） 和 00 1a（26） 表示它引用了常量池中 #25 和 #26

项来获得这个方法的【所属类】和【方法名】

0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07

第#5项 07 表示一个 Class 信息，00 1b（27） 表示它引用了常量池中 #27 项

0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07

第#6项 07 表示一个 Class 信息，00 1c（28） 表示它引用了常量池中 #28 项

0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07

0000040 00 1c 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29

第#7项 01 表示一个 utf8 串，00 06 表示长度，3c 69 6e 69 74 3e 是【 】

0000040 00 1c 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29

第#8项 01 表示一个 utf8 串，00 03 表示长度，28 29 56 是【()V】其实就是表示无参、无返回值

0000040 00 1c 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29

0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e

第#9项 01 表示一个 utf8 串，00 04 表示长度，43 6f 64 65 是【Code】

0000060 56 **01 00 04 43 6f 64 65 **01 00 0f 4c 69 6e 65 4e

第#10项 01 表示一个 utf8 串，00 0f（15） 表示长度，4c 69 6e 65 4e 75 6d 62 65 72 54 61 62 6c 65是【LineNumberTable】

0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e

0000100 75 6d 62 65 72 54 61 62 6c 65 01 00 12 4c 6f 63

第#11项 01 表示一个 utf8 串，00 12（18） 表示长度，4c 6f 63 61 6c 56 61 72 69 61 62 6c 65 54 61

62 6c 65是【LocalVariableTable】

0000100 75 6d 62 65 72 54 61 62 6c 65 01 00 12 4c 6f 63

0000120 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65 01

第#12项 01 表示一个 utf8 串，00 04 表示长度，74 68 69 73 是【this】

0000120 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65 01

0000140 00 04 74 68 69 73 01 00 1d 4c 63 6e 2f 69 74 63

第#13项 01 表示一个 utf8 串，00 1d（29） 表示长度，是【Lcn/wzk/jvm/t5/HelloWorld;】

0000140 00 04 74 68 69 73 01 00 1d 4c 63 6e 2f 69 74 63

0000160 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c 6f

0000200 57 6f 72 6c 64 3b 01 00 04 6d 61 69 6e 01 00 16

第#14项 01 表示一个 utf8 串，00 04 表示长度，74 68 69 73 是【main】

0000200 57 6f 72 6c 64 3b 01 00 04 6d 61 69 6e 01 00 16

第#15项 01 表示一个 utf8 串，00 16（22） 表示长度，是【([Ljava/lang/String;)V】其实就是参数为字符串数组，无返回值

0000200 57 6f 72 6c 64 3b 01 00 04 6d 61 69 6e 01 00 16

0000220 28 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72

0000240 69 6e 67 3b 29 56 01 00 04 61 72 67 73 01 00 13

第#16项 01 表示一个 utf8 串，00 04 表示长度，是【args】

0000240 69 6e 67 3b 29 56 01 00 04 61 72 67 73 01 00 13

第#17项 01 表示一个 utf8 串，00 13（19） 表示长度，是【[Ljava/lang/String;】

0000240 69 6e 67 3b 29 56 01 00 04 61 72 67 73 01 00 13

0000260 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69

0000300 6e 67 3b 01 00 10 4d 65 74 68 6f 64 50 61 72 61

第#18项 01 表示一个 utf8 串，00 10（16） 表示长度，是【MethodParameters】

0000300 6e 67 3b 01 00 10 4d 65 74 68 6f 64 50 61 72 61

0000320 6d 65 74 65 72 73 01 00 0a 53 6f 75 72 63 65 46

第#19项 01 表示一个 utf8 串，00 0a（10） 表示长度，是【SourceFile】

0000320 6d 65 74 65 72 73 01 00 0a 53 6f 75 72 63 65 46

0000340 69 6c 65 01 00 0f 48 65 6c 6c 6f 57 6f 72 6c 64

第#20项 01 表示一个 utf8 串，00 0f（15） 表示长度，是【HelloWorld.java】

0000340 69 6c 65 01 00 0f 48 65 6c 6c 6f 57 6f 72 6c 64

0000360 2e 6a 61 76 61 0c 00 07 00 08 07 00 1d 0c 00 1e

第#21项 0c 表示一个 【名+类型】，00 07 00 08 引用了常量池中 #7 #8 两项

0000360 2e 6a 61 76 61 0c 00 07 00 08 07 00 1d 0c 00 1e

第#22项 07 表示一个 Class 信息，00 1d（29） 引用了常量池中 #29 项

0000360 2e 6a 61 76 61 0c 00 07 00 08 07 00 1d 0c 00 1e

第#23项 0c 表示一个 【名+类型】，00 1e（30） 00 1f （31）引用了常量池中 #30 #31 两项

0000360 2e 6a 61 76 61 0c 00 07 00 08 07 00 1d 0c 00 1e

0000400 00 1f 01 00 0b 68 65 6c 6c 6f 20 77 6f 72 6c 64

第#24项 01 表示一个 utf8 串，00 0f（15） 表示长度，是【hello world】

0000400 00 1f 01 00 0b 68 65 6c 6c 6f 20 77 6f 72 6c 64

第#25项 07 表示一个 Class 信息，00 20（32） 引用了常量池中 #32 项

0000420 07 00 20 0c 00 21 00 22 01 00 1b 63 6e 2f 69 74

第#26项 0c 表示一个 【名+类型】，00 21（33） 00 22（34）引用了常量池中 #33 #34 两项

0000420 07 00 20 **0c 00 21 00 22 **01 00 1b 63 6e 2f 69 74

第#27项 01 表示一个 utf8 串，00 1b（27） 表示长度，是【cn/wzk/jvm/t5/HelloWorld】

0000420 07 00 20 0c 00 21 00 22 01 00 1b 63 6e 2f 69 74

0000440 63 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c

0000460 6f 57 6f 72 6c 64 01 00 10 6a 61 76 61 2f 6c 61

第#28项 01 表示一个 utf8 串，00 10（16） 表示长度，是【java/lang/Object】

0000460 6f 57 6f 72 6c 64 01 00 10 6a 61 76 61 2f 6c 61

0000500 6e 67 2f 4f 62 6a 65 63 74 01 00 10 6a 61 76 61

第#29项 01 表示一个 utf8 串，00 10（16） 表示长度，是【java/lang/System】

0000500 6e 67 2f 4f 62 6a 65 63 74 01 00 10 6a 61 76 61

0000520 2f 6c 61 6e 67 2f 53 79 73 74 65 6d 01 00 03 6f

第#30项 01 表示一个 utf8 串，00 03 表示长度，是【out】

0000520 2f 6c 61 6e 67 2f 53 79 73 74 65 6d 01 00 03 6f

0000540 75 74 01 00 15 4c 6a 61 76 61 2f 69 6f 2f 50 72

第#31项 01 表示一个 utf8 串，00 15（21） 表示长度，是【Ljava/io/PrintStream;】

0000540 75 74 01 00 15 4c 6a 61 76 61 2f 69 6f 2f 50 72

0000560 69 6e 74 53 74 72 65 61 6d 3b 01 00 13 6a 61 76

第#32项 01 表示一个 utf8 串，00 13（19） 表示长度，是【java/io/PrintStream】

0000560 69 6e 74 53 74 72 65 61 6d 3b 01 00 13 6a 61 76

0000600 61 2f 69 6f 2f 50 72 69 6e 74 53 74 72 65 61 6d

第#33项 01 表示一个 utf8 串，00 07 表示长度，是【println】

0000620 01 00 07 70 72 69 6e 74 6c 6e 01 00 15 28 4c 6a

第#34项 01 表示一个 utf8 串，00 15（21） 表示长度，是【(Ljava/lang/String;)V】

0000620 01 00 07 70 72 69 6e 74 6c 6e 01 00 15 28 4c 6a

0000640 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

4.1.4 访问标识与继承信息

21 表示该 class 是一个类，公共的

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

05 表示根据常量池中 #5 找到本类全限定名

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

06 表示根据常量池中 #6 找到父类全限定名

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

表示接口的数量，本类为 0

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

Flag Name Value Interpretation
ACC_PUBLIC 0x0001 Declared public ; may be accessed from outside its package.
ACC_FINAL 0x0010 Declared final ; no subclasses allowed.
ACC_SUPER 0x0020 Treat superclass methods specially when invoked by the invokespecial instruction.
ACC_INTERFACE 0x0200 Is an interface, not a class.
ACC_ABSTRACT 0x0400 Declared abstract ; must not be instantiated.
ACC_SYNTHETIC 0x1000 Declared synthetic; not present in the source code.
ACC_ANNOTATION 0x2000 Declared as an annotation type.
ACC_ENUM 0x4000 Declared as an enum type.

4.1.5 Field 信息

表示成员变量数量，本类为 0

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

FieldType Type Interpretation
B byte signed byte
C char Unicode character code point in the Basic Multilingual Plane, encoded with UTF-16
D double double-precision floating-point value
F float single-precision floating-point value
I int integer
J long long integer
L ClassName ; reference an instance of class ClassName
S short signed short
Z boolean true or false
J reference one array dimension

4.1.6 Method 信息

表示方法数量，本类为 2

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

一个方法由 访问修饰符，名称，参数描述，方法属性数量，方法属性组成

  • 红色代表访问修饰符（本类中是 public）
  • 蓝色代表引用了常量池 #07 项作为方法名称
  • 绿色代表引用了常量池 #08 项作为方法参数描述
  • 黄色代表方法属性数量，本方法是 1
  • 红色代表方法属性
    • 00 09 表示引用了常量池 #09 项，发现是【Code】属性
    • 00 00 00 2f 表示此属性的长度是 47
    • 00 01 表示【操作数栈】最大深度
    • 00 01 表示【局部变量表】最大槽（slot）数
    • 00 00 00 05 表示字节码长度，本例是 5
    • 2a b7 00 01 b1 是字节码指令
    • 00 00 00 02 表示方法细节属性数量，本例是 2
    • 00 0a 表示引用了常量池 #10 项，发现是【LineNumberTable】属性
      • 00 00 00 06 表示此属性的总长度，本例是 6
      • 00 01 表示【LineNumberTable】长度
      • 00 00 表示【字节码】行号 00 04 表示【java 源码】行号
    • 00 0b 表示引用了常量池 #11 项，发现是【LocalVariableTable】属性
      • 00 00 00 0c 表示此属性的总长度，本例是 12
      • 00 01 表示【LocalVariableTable】长度
      • 00 00 表示局部变量生命周期开始，相对于字节码的偏移量
      • 00 05 表示局部变量覆盖的范围长度
      • 00 0c 表示局部变量名称，本例引用了常量池 #12 项，是【this】
      • 00 0d 表示局部变量的类型，本例引用了常量池 #13 项，是 【Lcn/wzk/jvm/t5/HelloWorld;】
      • 00 00 表示局部变量占有的槽位（slot）编号，本例是 0

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

0000700 00 07 00 08 00 01 00 09 00 00 00 2f 00 01 00 01

0000720 00 00 00 05 2a b7 00 01 b1 00 00 00 02 00 0a 00

0000740 00 00 06 00 01 00 00 00 04 00 0b 00 00 00 0c 00

0000760 01 00 00 00 05 00 0c 00 0d 00 00 00 09 00 0e 00

  • 红色代表访问修饰符（本类中是 public static）
  • 蓝色代表引用了常量池 #14 项作为方法名称
  • 绿色代表引用了常量池 #15 项作为方法参数描述
  • 黄色代表方法属性数量，本方法是 2
  • 红色代表方法属性（属性1）
    • 00 09 表示引用了常量池 #09 项，发现是【Code】属性
    • 00 00 00 37 表示此属性的长度是 55
    • 00 02 表示【操作数栈】最大深度
    • 00 01 表示【局部变量表】最大槽（slot）数
    • 00 00 00 05 表示字节码长度，本例是 9
    • b2 00 02 12 03 b6 00 04 b1 是字节码指令
    • 00 00 00 02 表示方法细节属性数量，本例是 2
    • 00 0a 表示引用了常量池 #10 项，发现是【LineNumberTable】属性
      • 00 00 00 0a 表示此属性的总长度，本例是 10
      • 00 02 表示【LineNumberTable】长度
      • 00 00 表示【字节码】行号 00 06 表示【java 源码】行号
      • 00 08 表示【字节码】行号 00 07 表示【java 源码】行号
    • 00 0b 表示引用了常量池 #11 项，发现是【LocalVariableTable】属性
      • 00 00 00 0c 表示此属性的总长度，本例是 12
      • 00 01 表示【LocalVariableTable】长度
      • 00 00 表示局部变量生命周期开始，相对于字节码的偏移量
      • 00 09 表示局部变量覆盖的范围长度
      • 00 10 表示局部变量名称，本例引用了常量池 #16 项，是【args】
      • 00 11 表示局部变量的类型，本例引用了常量池 #17 项，是【[Ljava/lang/String;】
      • 00 00 表示局部变量占有的槽位（slot）编号，本例是 0

0000760 01 00 00 00 05 00 0c 00 0d 00 00 00 09 00 0e 00

0001000 0f 00 02 00 09 00 00 00 37 00 02 00 01 00 00 00

0001020 09 b2 00 02 12 03 b6 00 04 b1 00 00 00 02 00 0a

0001040 00 00 00 0a 00 02 00 00 00 06 00 08 00 07 00 0b

0001060 00 00 00 0c 00 01 00 00 00 09 00 10 00 11 00 00

红色代表方法属性（属性2）

  • 00 12 表示引用了常量池 #18 项，发现是【MethodParameters】属性

    • 00 00 00 05 表示此属性的总长度，本例是 5
    • 01 参数数量
    • 00 10 表示引用了常量池 #16 项，是【args】
    • 00 00 访问修饰符

0001100 00 12 00 00 00 05 01 00 10 00 00 00 01 00 13 00

0001120 00 00 02 00 14

4.1.7 附加属性

  • 00 01 表示附加属性数量
  • 00 13 表示引用了常量池 #19 项，即【SourceFile】
  • 00 00 00 02 表示此属性的长度
  • 00 14 表示引用了常量池 #20 项，即【HelloWorld.java】

0001100 00 12 00 00 00 05 01 00 10 00 00 00 01 00 13 00

0001120 00 00 02 00 14

参考文献 https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html

4.2字节码指令

4.2.1 入门

接着上一节，研究一下两组字节码指令，一个是

public cn.wzk.jvm.t5.HelloWorld(); 构造方法的字节码指令

2a b7 00 01 b1

  1. 2a => aload_0 加载 slot 0 的局部变量，即 this，做为下面的 invokespecial 构造方法调用的参数
  2. b7 => invokespecial 预备调用构造方法，哪个方法呢？
  3. 00 01 引用常量池中 #1 项，即【 Method java/lang/Object.“”

    JVM核心内容详细讲解相关推荐

    1. 视频 TS 内容详细讲解

      视频 TS 内容详细讲解 题记:时间戳将每一秒分成90000份,即将每一毫秒分成90份 MPEG2系统用于视音频同步以及系统时钟恢复的时间标签分别在ES,PES和TS这3个层次中. 在TS 层, TS ...

    2. OpenGL核心模式详细讲解[结合LearnOpenGL]

      OpenGL立即渲染模式&核心模式 OpenGL (for"Open Graphics Library") is an API (Application Programmi ...

    3. sublime搭建C/C++编译环境（超完美的配置并配上内容详细讲解！！）

      简述 有两台电脑,之前的电脑上就有之前好基友分享的cpp配置. 但是另外一台电脑上,一开始就没有配置这个. 然后,在网上搜,发现搜到的那些配置.抱歉,我的意思是,在坐的各位都是垃圾 我的C/C++的配 ...

    4. 一文详细讲解API网关核心功能和API管理扩展

      本文将详细讲解API网关的基础概念,使用场景和核心功能,以及基于API网关核心引擎做的API全生命周期管理功能扩展等,最后介绍当前主流的开源API网关引擎. API网关概述 在微服务架构体系里面,我们 ...

    5. 蓝牙聊天App设计3：Android Studio制作蓝牙聊天通讯软件（完结，蓝牙连接聊天，结合生活情景进行蓝牙通信的通俗讲解，以及代码功能实现，内容详细，讲解通俗易懂）

      前言:蓝牙聊天App设计全部有三篇文章(一.UI界面设计,二.蓝牙搜索配对连接实现,三.蓝牙连接聊天),这篇文章是:三.蓝牙连接聊天. 课程1:Android Studio小白安装教程,以及第一个An ...

    6. python中逻辑运算符and，or的用法以及运算的核心思想——“短路逻辑”超详细讲解

      python中and和or的用法以及运算的核心思想--"短路逻辑"超详细讲解 //本文几乎涵盖了and和or所有知识点,篇幅较长,一点要静下心来看,学无止境. 1.and和or的含 ...

    7. 【JVM】JVM内存模型(详细)

      目录 一.JVM概述 1.jvm简介 2.jvm作用 3.jvm的内存模型 二.类加载器 1.类加载器的作用 2.加载器的类型 3.双亲委派机制的运行过程 4.双亲委派机制优缺点 5.为什么要破坏双亲 ...

    8. JAVA数组详细讲解

      在程序开发过程中,有时候需要存储大量的同类型数据.例如,存储一个班级50名学生的姓名,这时需要定义50个变量来保存姓名数据,但这种做法太繁琐了.那么,如何解决这类问题呢?Java语言提供了数组结构,它 ...

    9. Android架构详细讲解与C/C++开发支持原理

      Android架构详细讲解与C/C++开发支持原理 在Android 在NDK r5使用C/C++进行开发.(以前,Android 对C/C++开发的支持仅限于用C/C++开发动态链接库,然后在Jav ...

    最新文章

    1. 车辆2D/3D--Deep MANTA: A Coarse-to-fine Many-Task Network for joint 2D and 3D vehicle analysis
    2. CSS的一些基础知识
    3. python构造方法与java区别_一张图秒懂Java和Python的区别，你知道吗？
    4. 固态器件理论（11）超导设备
    5. OpenCV-Python 彩色图像均衡化与规定化
    6. 以太坊Oracle系列一: Human Oracle
    7. MySQL查询，按拼音首字母排序
    8. 团队作业8—团队项目用户验收评审
    9. 实体类equals/hashCode
    10. PyTorch 1.0 中文文档：torch.utils.dlpack
    11. 王腾晒Redmi K30 Pro拆机视频：创新“三明治”主板
    12. 济南2021高考成绩查询,@全体济南人：2021夏季高考时间公布！
    13. 成都高端企业网站建设前网站推广优化战略规划成都辰星建站
    14. URL 编码 - 从 %00 到 %ff
    15. 粒子群算法(7)------粒子群算法局部版本的实现
    16. 读《出梁庄记》乱摘2
    17. “应用程序无响应”原因汇总
    18. 【批处理DOS-CMD命令-汇总和小结】-磁盘管理和修复、磁盘和分区属性的管理、设置隐藏分区卷（convert、diskpart、chkdsk）
    19. Primo.Ramdisk.Srv.Mui.Setup安装配置教程
    20. Macbook如何打开Chrome调试工具Developer Tools

    热门文章

    1. peek在c语言中的作用,聚醚醚酮(PEEK)材料用于颅骨修补优点有哪些
    2. 面部AR遥控器：使用AR制作动画
    3. 基于51单片机的自动浇花系统
    4. CSharpSCADA - 工控网关, 轻量级组态软件.
    5. 几款漂亮的Eclipse编辑器皮肤
    6. 绝地求生组装电脑配置推荐2021 适合玩吃鸡游戏电脑清单
    7. 设置杀怪KillMonBurstRate爆率、KillMonExpRate经验倍数
    8. 阿里聚安全发布 企业可享淘宝同款防护
    9. Android下拉刷新的实现(一) - SwipeRefreshLayout篇
    10. mac bigsur python3.8 安装pillow失败