jvm学习

引言

本博客是根据黑马程序员JVM完整教程教学视频学习时，所做的笔记

ps: 实际字数没那么多，上面显示的是字符数

1.内存结构

1.1 程序计数器

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

1.1.1 作用

是记住下一条jvm指令的执行地址

(例如解释器取出3后，4就会存入程序计数器)

image-20220806164540695

1.1.2 特点

是线程私有的（每个线程都有自己私有的程序计数器）；

不会存在内存溢出

1.2 虚拟机栈

1.2.1 定义

Java Virtual Machine Stacks （Java 虚拟机栈）

每个线程运行时所需要的内存，称为虚拟机栈

每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存

每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

image-20220806165228402

image-20220806165238256

问题辨析

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

答：不涉及、垃圾回收是回收的堆内存的无用对象

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

答：不是，会使线程变少

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

答：如果方法内局部变量没有逃离方法的作用访问，它是线程安全的

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

1.2.2 栈内存溢出

  • 栈帧过多导致栈内存溢出（比如典型的递归、当没有设置正确的递归边界 ）
  • 栈帧过大导致栈内存溢出（很少出现）

1.3 本地方法栈

就是有些代码底层是由C/C++实现的就是操作系统的方法，Java只需要用native标记一下即可、比如Object下的clone()、HashCode()；

1.4 堆

1.4.1 定义

Heap 堆

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

特点:

它是线程共享的，堆中对象都需要考虑线程安全的问题

有垃圾回收机制

1.4.2 堆内存溢出

不断的产生对象、且有人使用它、渐渐的就会产生堆内存溢出

java.lang.OutofMemoryError ：java heap space. 堆内存溢出

可以使用 -Xmx8m 来指定堆内存大小。

1.5 方法区

1.5.1 定义

Method Area

The Java Virtual Machine has a method area that is shared among all Java Virtual Machine threads. The method area is analogous to the storage area for compiled code of a conventional language or analogous to the “text” segment in an operating system process. It stores per-class structures such as the run-time constant pool, field and method data, and the code for methods and constructors, including the special methods (§2.9) used in class and instance initialization and interface initialization.

Java虚拟机具有一个方法区域，该方法区域在所有Java虚拟机线程中共享。该方法区域类似于存储区域的常规语言代码或类似于操作系统过程中的“文本”段。它存储了每个类结构，例如运行时常数池，字段和方法数据以及方法和构造函数的代码，包括类和实例初始化和接口初始化中使用的特殊方法（§2.9）。

The method area is created on virtual machine start-up. Although the method area is logically part of the heap, simple implementations may choose not to either garbage collect or compact it. This specification does not mandate the location of the method area or the policies used to manage compiled code. The method area may be of a fixed size or may be expanded as required by the computation and may be contracted if a larger method area becomes unnecessary. The memory for the method area does not need to be contiguous.

方法区域是在虚拟机启动时创建的。尽管方法区域*在逻辑上是堆的一部分，但简单的实现可能会选择不收集或压实垃圾。该规范不要求方法区域的位置或用于管理编译代码的策略。方法区域可能具有固定尺寸，也可以根据计算的要求进行扩展，如果不需要较大的方法区域，则可能会收缩。方法区域的内存不需要连续。

1.5.2 组成

image-20220806170008456

JDK1.8之前方法区用的实际上还是堆的内存；JDK1.8之后直接使用的操作系统的内存空间

1.5.3 方法区内存溢出

内存不够都会溢出，只不过1.8之后使用操作系统的内存空间，很难溢出，可以自行设置大小；

1.5.4 StringTable

1.5.4.1 面试题

image-20220806170243400

image-20220806170303658

System.Out.println(s3 == s4); false

image-20220806170354667

System.Out.println(s3 == s5); true

image-20220806170435116

简单来说，就是常量不会变；变量会新建；更详细解释看下节绿字

1.5.4.2 StringTable特性

  • 常量池中的字符串仅是符号，第一次用到时才变为对象
  • 字符串变量拼接的原理是 StringBuilder （1.8）
  • 字符串常量拼接的原理是编译期优化
  • 可以使用 intern 方法，主动将串池中还没有的字符串对象放入串池
    • 1.8 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串池中的对象返回
    • 1.6 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有会把此对象复制一份（此时堆中的和串池中的已经不一样了），放入串池， 会把串池中的对象返回
    • 详细如下图

image-20220806170806080

s仍然在堆中，复制了一份s放入串池并赋给s2；所以s2 == x；s！= x

在1.8中 没有复制而是直接放入，所以s2 == x；s == x

image-20220806170831409

image-20220806170843063

image-20220806170853985

image-20220806171000537

1.5.4.3 StringTable位置

image-20220806171039427

1.8串池用的是堆空间，1.6用的是永久代空间

1.5.4.4 StringTable垃圾回收

StrnigTable存在垃圾回收机制

1.5.4.5 StringTable性能调优

调整 -XX:StringTableSize=桶个数

桶的个数越多，哈希碰撞越少；因为每存放一个串时都要先查找当前StringTable中是否存在，若存在则不添加，不存在就添加；

如果存在字符串重复的问题，可以考虑将字符串入池，减少内存占用；

1.6 直接内存

1.6.1 定义

Direct Memory

  • 常见于 NIO 操作时，用于数据缓冲区

  • 分配回收成本较高，但读写性能高

  • 不受 JVM 内存回收管理

image-20220806171447515

1.6.2 分配和回收原理

没太理解：45_直接内存_释放原理_哔哩哔哩_bilibili

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

2. 垃圾回收

2.1 如何判断对象可以回收

2.1.1 引用计数法

只要一个对象被其他变量所引用，就让它的计数加1，被引用了两次就让它的计数变成2，当这个变量的计数变成0时，就可以被垃圾回收；

弊端：当出现如下图的情况，A对象引用了B对象，B对象也引用了A对象，所以A，B的计数均为1，但是没有其他的引用它们俩；虽然应该被垃圾回收，但是因为计数不为0，则无法进行回收

image-20220811163138061

2.1.2 可达性计数法

  • Java 虚拟机中的垃圾回收器采用可达性分析来探索所有存活的对象

  • 扫描堆中的对象，看是否能够沿着 GC Root对象（根对象） 为起点的引用链找到该对象，找不到，表示可以回收（就是先确定好一定不会被回收的对象作为根对象，然后查找目标对象是否直接或者间接被根对象所引用）

  • 哪些对象可以作为 GC Root ?

    • GCRoot对象包括：虚拟机栈终点局部变量表引用的对象，方法区中类静态属性引用和常量引用对象，本地方法栈中的对象

2.1.3 五种引用(面试常考)

image-20220811163328291

2.1.3.1 强引用

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

    如上图、只有B、C对象都不引用A1对象时，A1对象才会在垃圾回收时被回收；

2.1.3.2 软引用（SoftReference）

  • 仅有软引用引用该对象时，在垃圾回收后，内存仍不足时会再次出发垃圾回收，回收软引用对象（实在不行了才回收软引用对象）
  • 可以配合引用队列来释放软引用自身（因为软引用对象自身也是占一点内存的）

软引用的使用

image-20220811163603544

image-20220811163628973

可见前四次已经被回收了；

引用队列的使用：

如果在垃圾回收时发现内存不足，在回收软引用所指向的对象时，软引用本身不会被清理（就是上图结果中的null值）

如果想要清理软引用，需要使用引用队列

image-20220811163843846

2.1.3.3 弱引用（WeakReference）

  • 仅有弱引用引用该对象时，在垃圾回收时，**(full gc时)无论内存是否充足，都会回收**弱引用对象

  • 可以配合引用队列来释放弱引用自身

image-20220811164041023

结合引用队列同软引用相似

2.1.3.4 虚引用（PhantomReference）

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

2.1.3.5 终结器引用（FinalReference）

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

2.2 垃圾回收算法(重要)

2.2.1 标记清除算法

定义：标记清除算法顾名思义，是指在虚拟机执行垃圾回收的过程中，先采用标记算法确定可回收对象，然后垃圾收集器根据标识清除相应的内容，给堆内存腾出相应的空间

image-20220811164255455

清除后，对于腾出内存空间并不是将内存空间的字节清0，而是会把被清除对象所占用内存的起始结束的地址记录下来，放入空闲的地址列表中，下次分配内存的时候，再选择合适的位置存入，直接覆盖

优点：速度快；

缺点：容易产生大量的内存碎片，可能无法满足大对象的内存分配，一旦导致无法分配对象，那就会导致jvm启动gc，一旦启动gc，我们的应用程序就会暂停，这就导致应用的响应速度变慢

2.2.2 标记整理算法

标记-整理 会将不被GC Root引用的对象回收，清楚其占用的内存空间。然后整理剩余的对象，速度慢、可以有效避免因内存碎片而导致的问题，但是因为整体需要消耗一定的时间，所以效率较低

2.2.3 复制算法

复制算法将内存分为等大小的两个区域，FROM和TO（TO中始终为空）。先将被GC Root引用的对象从FROM放入TO中，再回收不被GC Root引用的对象。然后交换FROM和TO。这样也可以避免内存碎片的问题，但是会占用双倍的内存空间。

image-20220811164455902

2.3 分代垃圾回收

2.3.1回收流程

① 新创建的对象都被放在新生代的伊甸园中

image-20220811164541767

② 当伊甸园空间不足时，会采用复制算法进行垃圾回收，这时的回收叫做Minor GC；把伊甸园和幸存区From存活的对象先复制到幸存区To中，此时存活的对象寿命+1，并清理掉未存活的对象，最后再交换幸存区From和幸存区To；

image-20220811164612870

image-20220811164720253

image-20220811164727571

③ 再次创建对象，若新生代的伊甸园又满了，则同上；

④ 如果经历多次垃圾回收，某一对象均未被回收，寿命不断+1，当寿命达到阈值时（最大为15，4bit）就会被放入老年代中；

image-20220811164852925

⑤ 如果老年代中的内存都满了，就会先触发Minor GC 如果内存还是不足，则会触发Full GC，扫描新生代和老年代中所有不再使用的对象并回收、

总结

  • 对象首先分配在伊甸园区域

  • 新生代空间不足时，触发 minor gc，伊甸园和 from 存活的对象使用 copy 复制到 to 中，存活的对象年龄加 1并且交换 from to

  • minor gc 会引发 stop the world，暂停其它用户的线程，等垃圾回收结束，用户线程才恢复运行

  • 当对象寿命超过阈值时，会晋升至老年代，最大寿命是15（4bit）

  • 当老年代空间不足，会先尝试触发 minor gc，如果之后空间仍不足，那么触发 full gc，STW的时间更长

2.3.2 GC 分析

代码-GC分析

2.3.2.1 大对象处理策略

当遇到一个较大的对象时，就算新生代的伊甸园为空，也无法容纳该对象时，会将该对象直接晋升为老年代

2.3.2.2 线程内存溢出

某个线程的内存溢出了而抛异常（out of memory），不会让其他的线程结束运行

这是因为当一个线程抛出OOM异常后，它所占据的内存资源会全部被释放掉，从而不会影响其他线程的运行，进程依然正常

2.4 垃圾回收器

串行

  • 单线程

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

吞吐量优先

  • 多线程

  • 堆内存较大，多核 cpu

  • 让单位时间内，STW 的时间最短 0.2 0.2 = 0.4，垃圾回收时间占比最低，这样就称吞吐量高（少餐多食）

响应时间优先

  • 多线程

  • 堆内存较大，多核 cpu

  • 尽可能让单次 STW 的时间最短 0.1 0.1 0.1 0.1 0.1 = 0.5（少食多餐）

2.4.1 串行

image-20220811170019886

安全点：

让其他线程都在这个点停下来，以免垃圾回收时移动对象地址，使得其他线程找不到被移动的对象；因为是串行的，所以只有一个垃圾回收线程。且在该线程执行回收工作时，其他线程进入阻塞状态

Serial 收集器：

Serial收集器是最基本的、发展历史最悠久的收集器

特点：单线程、简单高效（与其他收集器的单线程相比），用于新生代采用复制算法。对于限定单个CPU的环境来说，Serial收集器由于没有线程交互的开销，专心做垃圾收集自然可以获得最高的单线程手机效率。收集器进行垃圾回收时，必须暂停其他所有的工作线程，直到它结束（Stop The World）

Serial Old 收集器：

Serial Old是Serial收集器的老年代版本

特点：同样是单线程收集器，采用标记-整理算法

2.4.2 吞吐量优先

-XX:+UseParallelGC ~ -XX:+UserParallelOldGC：

开启吞吐量优先的回收器，1.8版本默认开启；UseParallelGC是新生代的，采用复制算法；UserParallelOldGC是在老年代的，采用标记整理算法

-XX:+UseAdaptiveSizePolicy：

开启这个将采用自适应的大小调整策略，调整新生代的大小，包括堆的大小和晋升老年代的阈值大小等；种调节方式称为GC的自适应调节策略

-XX:GCTimeRatio=ratio：

调整吞吐量的目标，即垃圾回收的时间与总时间的占比（1/(1+ratio)），默认ratio=99，1/(1+ratio)）= 0.01，即垃圾回收的时间不能超过总时间的1%（比如总时间100分钟，垃圾回收的时间不能超过1分钟，如果超过1分钟，则GC会自适应的调整大小）

-XX:MaxGCPauseMillis=ms：

指的是暂停的毫秒数，默认200ms，即上图红线（和Ratio对立，折中选取）

-XX:ParallelGCThreads=n：

设置垃圾回收时运行的线程数

2.4.3 响应时间优先（CMS）

image-20220811165832530

CMS 收集器

Concurrent Mark Sweep，一种以获取最短回收停顿时间为目标的老年代收集器

特点：基于标记-清除算法实现。并发收集、低停顿，但是会产生内存碎片

应用场景：适用于注重服务的响应速度，希望系统停顿时间最短，给用户带来更好的体验等场景下。如web程序、b/s服务

CMS收集器的运行过程分为下列4步：

初始标记：标记GC Roots能直接到的对象。速度很快但是仍存在Stop The World问题

并发标记：进行GC Roots Tracing 的过程，找出存活对象且用户线程可并发执行

重新标记：为了修正并发标记期间因用户程序继续运行而导致标记产生变动的那一部分对象的标记记录。仍然存在Stop The World问题

并发清除：对标记的对象进行清除回收

CMS收集器的内存回收过程是与用户线程一起并发执行的

图解：

image-20220811170156714

2.4.4 G1(Garbage First)

JDK1.9默认采用G1垃圾回收器，且废弃的CMS回收器

2.4.4.1 适用场景

  • 同时注重吞吐量（Throughput）和低延时（Low latency），默认的暂停目标是200ms

  • 超大堆内存，会将堆划分为多个大小相等的区域，称为Region，每个区域都可以独立的作为伊甸园或者新生代或者老年代

  • 整体上是标记-整理算法，在两个区域之间是复制算法

2.4.4.2 相关jvm参数

image-20220811170405861

2.4.4.3 G1垃圾回收阶段

image-20220811170444758

新生代伊甸园垃圾回收—–>内存不足，新生代回收+并发标记—–>回收新生代伊甸园、幸存区、老年代内存——>新生代伊甸园垃圾回收(重新开始)

Young Collection

image-20220811170657465

Young Collection + CM

  • 在 Young GC 时会进行 GC Root 的初始标记

  • 并发标记（CM）是从GC Root出发顺着其引用链标记其他对象

  • 老年代占用堆空间比例达到阈值时，进行并发标记（不会 STW），由下面的 JVM 参数决定

-XX:InitiatingHeapOccupancyPercent=percent （默认45%）如下图 O 占总的45%时进行并发标记

image-20220811170809004

Mixed Collection

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

最终标记（Remark见2.4.4.6）会 STW

拷贝存活（Evacuation）会 STW

-XX:MaxGCPauseMillis=ms

image-20220811170917470

黑线：即新生代回收，包括伊甸园、幸存区

红线：复制老年代

问：为什么有的老年代被拷贝了，有的没拷贝？

答：因为指定了最大停顿时间，如果对所有老年代都进行回收，耗时可能过高。为了保证时间不超过设定的停顿时间，会回收最有价值的老年代（回收后，能够得到更多内存）

2.4.4.4 Full GC

G1在老年代内存不足时（老年代所占内存超过阈值）

如果垃圾产生速度慢于垃圾回收速度，不会触发Full GC，还是并发地进行清理

如果垃圾产生速度快于垃圾回收速度，便会触发Full GC，退化到串行，STW时间会很长

2.4.4.5 Young Collection跨代引用

即老年代引用新生代的问题，因为在新生代回收过程中会沿着GC Root去标记，这些GC Root可能存在于老年代中，而一般老年代中的对象较多，这样每次都需要遍历大量对象；

解决方法：

  • 卡表与Remembered Set：

    • Remembered Set 存在于E中，用于保存新生代对象对应的脏卡，将来对新生代进行垃圾回收时，会根据Remembered Set判断有哪些脏卡，然后再从这些脏卡开始
      • 脏卡：O被划分为多个区域（一个区域512K），如果该区域引用了新生代对象，则该区域被称为脏卡

  • 在引用变更时通过post-write barried + dirty card queue，相当于更新脏卡

  • concurrent refinement threads 更新 Remembered Set

image-20220811171202341

2.4.4.6 Reamark重标记

黑色：已被处理，需要保留的

灰色：正在处理中的

白色：还未处理的

image-20220811171419280

① 这个时候将处理B，处理结果如下：

image-20220811171445088

② 下一步将处理C，此时正在并发执行标记，用户线程可能改变B和C的引用关系，会产生如下情况：

image-20220811171506442

③ 此时C已经被处理完了，被标记成了白色，但是用户线程可能在这时又改变了C的引用：

image-20220811171531614

④ 此时C应该被标记成黑色，但是标记动作已经结束，所以会产生误差；

解决方法：采用Remark

过程如下

① 之前C未被引用，这时A引用了C，就会给C加一个写屏障，写屏障的指令会被执行（只有发生引用改变就会执行），将C放入一个队列当中，并将C变为 处理中 状态

② 在并发标记阶段结束以后，重新标记阶段会STW，然后将放在该队列中的对象重新处理发现有强引用引用它，就会处理它

image-20220811171613821

2.4.4.7 JDK8u20字符串去重

过程

① 将所有新分配的字符串（底层是char[]）放入一个队列

② 当新生代回收时，G1并发检查是否有重复的字符串

③ 如果字符串的值一样，就让他们引用同一个字符串对象

image-20220811171806398

注意，其与String.intern的区别

intern关注的是字符串对象

字符串去重关注的是char[]

在JVM内部，使用了不同的字符串标

优点与缺点

  • 节省了大量内存

  • 新生代回收时间略微增加，导致略微多占用CPU

2.4.4.8 JDK 8u40 并发标记类卸载

在并发标记阶段结束以后，就能知道哪些类不再被使用。如果一个类加载器的所有类都不在使用，则卸载它所加载的所有类

-XX:+ClassUnloadingWithConcurrentMark 默认启用

2.4.4.9 JDK 8u60 回收巨型对象

  • 一个对象大于region的一半时，就称为巨型对象
  • G1不会对巨型对象进行拷贝
  • 回收时被优先考虑
  • G1会跟踪老年代所有incoming引用，如果老年代incoming引用为0的巨型对象就可以在新生代垃圾回收时处理掉

image-20220811172031981

2.4.4.10 JDK9并发标记起始时间的调整

2.4.4.4提到当垃圾产生速度快于垃圾回收速度，便会触发Full GC，STW的时间就会变长，这个时候就可以通过调整提前开始并发标记来优化

  • 并发标记必须在堆空间占满前完成，否则退化为 FullGC

  • JDK 9 之前需要使用 -XX:InitiatingHeapOccupancyPercent

  • JDK 9 可以动态调整

-XX:InitiatingHeapOccupancyPercent 用来设置初始值

进行数据采样并动态调整

总会添加一个安全的空档空间

2.5 垃圾回收调优

2.5.1 确定调优领域

  • 内存
  • 锁竞争
  • CPU占用
  • IO
  • GC

2.5.2确定目标

低延迟/高吞吐量？ 选择合适的GC

  • CMS(JDK8默认)、 G1(JDK9推荐) 、ZGC(JDK12体验)
  • ParallelGC（高吞吐量）
  • Zing（另一种虚拟机）

2.5.3最快的GC是不发生GC

首先排除减少因为自身编写的代码而引发的内存问题

  • 查看Full GC前后的内存占用，考虑以下几个问题

    • 数据是不是太多？（比如select *）

    • 数据表示是否太臃肿

      • 对象图
      • 对象大小（比如用Integer换成int会小很多）

    • 是否存在内存泄漏（采用软、弱引用；第三方缓存实现等）

2.5.4新生代调优

新生代的特点

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

  • 死亡对象回收零代价

  • 大部分对象用过即死（朝生夕死）
  • MInor GC 所用时间远小于Full GC

问：新生代内存越大越好么？

答：不是

  • 新生代内存太小：频繁触发Minor GC，会STW，会使得吞吐量下降

  • 新生代内存太大：老年代内存占比有所降低，会更频繁地触发Full GC。而且触发Minor GC时，清理新生代所花费的时间会更长

  • 新生代内存设置为能容纳所有【并发量*(请求-响应)】的数据为宜

2.5.5幸存区调优

  • 幸存区需要能够保存 当前活跃对象+需要晋升的对象

  • 晋升阈值配置得当，让长时间存活的对象尽快晋升

-XX:MaxTenuringThreshold=threshold
-XX:+PrintTenuringDistribution

2.5.6老年代调优

以 CMS 为例

  • CMS 的老年代内存越大越好

  • 先尝试不做调优，如果没有 Full GC 那么已经…，否则先尝试调优新生代

  • 观察发生 Full GC 时老年代内存占用，将老年代内存预设调大 1/4 ~ 1/3

-XX:CMSInitiatingOccupancyFraction=percent

3. 类加载与字节码技术

3.1 类文件结构

首先获得.class字节码文件

方法：

  • 在文本文档里写入java代码（文件名与类名一致），将文件类型改为.java
  • java终端中，执行javac X:…\XXX.java

image-20220808172918938

1
2
3
4
5
6
// HelloWorld 示例
public class HelloWorld {
    public static void main(String[] args) {
    	System.out.println("hello world");
    }
}

以下是字节码文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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 14Copy

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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];

3.1.1 魔数

u4 magic

对应字节码文件的0~3个字节

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

3.1.2 版本

u2 minor_version;

u2 major_version;

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

34H = 52，代表JDK8

3.1.3 常量池

了解即可

查看文档阅读：https://gitee.com/Gu-taicheng/image/raw/master/document/3_%E7%B1%BB%E5%8A%A0%E8%BD%BD%E4%B8%8E%E5%AD%97%E8%8A%82%E7%A0%81%E6%8A%80%E6%9C%AF.pdf

3.2 字节码指令

3.2.1 javap工具

自己分析类文件结构太麻烦了，Oracle提供了javap工具来反编译class文件

1
javap -v D:\Main.class
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
C:\Thread_study>javap -v D:\Main.class
Classfile /D:\Main.class
  Last modified 2020-6-6; size 434 bytes
  MD5 checksum df1dce65bf6fb0b4c1de318051f4a67e
  Compiled from "Demo1.java"
public class com.nyima.JVM.day5.Demo1
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #6.#15         // java/lang/Object."<init>":()V
   #2 = Fieldref           #16.#17        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #18            // hello world
   #4 = Methodref          #19.#20        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #21            // com/nyima/JVM/day5/Demo1
   #6 = Class              #22            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               main
  #12 = Utf8               ([Ljava/lang/String;)V
  #13 = Utf8               SourceFile
  #14 = Utf8               Demo1.java
  #15 = NameAndType        #7:#8          // "<init>":()V
  #16 = Class              #23            // java/lang/System
  #17 = NameAndType        #24:#25        // out:Ljava/io/PrintStream;
  #18 = Utf8               hello world
  #19 = Class              #26            // java/io/PrintStream
  #20 = NameAndType        #27:#28        // println:(Ljava/lang/String;)V
  #21 = Utf8               com/nyima/JVM/day5/Demo1
  #22 = Utf8               java/lang/Object
  #23 = Utf8               java/lang/System
  #24 = Utf8               out
  #25 = Utf8               Ljava/io/PrintStream;
  #26 = Utf8               java/io/PrintStream
  #27 = Utf8               println
  #28 = Utf8               (Ljava/lang/String;)V
{
  public com.nyima.JVM.day5.Demo1();
    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 7: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String hello world
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V

         8: return
      LineNumberTable:
        line 9: 0
        line 10: 8
}Copy

3.2.2 图解方法执行流程

原始代码

1
2
3
4
5
6
7
8
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);   
    } 
}

3.2.2.1 常量池载入运行时常量池

常量池也属于方法区，只不过这里单独提出来了

image-20220808184345213

3.2.2.2 方法字节码载入方法区

image-20220808184729286

3.2.2.3 main 线程开始运行，分配栈帧内存

（stack=2，locals=4） 对应操作数栈有2个空间（每个空间4个字节），局部变量表中有4个槽位

image-20220808184801651

3.2.2.4 执行引擎开始执行字节码

bipush 10

  • 将一个 byte 压入操作数栈

    （其长度会补齐 4 个字节），类似的指令还有

    • sipush 将一个 short 压入操作数栈（其长度会补齐 4 个字节）
    • ldc 将一个 int 压入操作数栈
    • ldc2_w 将一个 long 压入操作数栈（分两次压入，因为 long 是 8 个字节）
    • 这里小的数字都是和字节码指令存在一起，超过 short 范围的数字存入了常量池(比如Short.MAX_VALUE + 1)

image-20220809002236917

istore_1

将操作数栈栈顶元素弹出，放入局部变量表的slot 1中

对应代码中的

1
a = 10

image-20220809002349798

ldc #3

  • 读取运行时常量池中#3，即32768(超过short最大值范围的数会被放到运行时常量池中)，将其加载到操作数栈中

  • 注意 Short.MAX_VALUE 是 32767，所以 32768 = Short.MAX_VALUE + 1 实际是在编译期间计算好的、

image-20220809002547059

istore_2

将操作数栈中的元素弹出，放到局部变量表的2号位置

对应着代码中的

1
b = 32768

image-20220809002645260

iload1、iload2

将局部变量表中1号位置和2号位置的元素放入操作数栈中

  • 因为只能在操作数栈中执行运算操作

image-20220809002922739

image-20220809002935532

iadd

将操作数栈中的两个元素弹出栈并相加，结果在压入操作数栈中

image-20220809003051071

istore 3

将操作数栈中的元素弹出，放入局部变量表的3号位置

对应代码中的

1
int c = a + b;

image-20220809003148724

getstatic #4

  • 在运行时常量池中找到#4，发现是一个对象

  • 在堆内存中找到该对象，并将其引用放入操作数栈中

image-20220809003412248

image-20220809003428927

iload 3

将局部变量表中3号位置的元素压入操作数栈中

image-20220809003627971

image-20220809003902007

invokevirtual 5
  • 找到常量池 #5 项
  • 定位到方法区 java/io/PrintStream.println:(I)V 方法
  • 生成新的栈帧（分配 locals、stack等）
  • 传递参数，执行新栈帧中的字节码

image-20220809004000867

  • 执行完毕，弹出栈帧
  • 清除 main 操作数栈内容

image-20220809004022928

return
  • 完成 main 方法调用
  • 弹出 main 栈帧，程序结束

3.2.3 练习-分析i++

源码：

1
2
3
4
5
6
7
8
9
10
11
/**
* 从字节码角度分析 a++ 相关题目
*/
public class Demo3_2 {
    public static void main(String[] args) {
        int a = 10;
        int b = a++ + ++a + a--;
        System.out.println(a);
        System.out.println(b);
    }
}

字节码code：

1
2
3
4
5
6
7
8
9
10
11
 0: bipush 10
 2: istore_1
 3: iload_1
 4: iinc 1, 1
 7: iinc 1, 1
10: iload_1
11: iadd
12: iload_1
13: iinc 1, -1
16: iadd
17: istore_2

分析：

  • 注意**iinc指令(自增指令)**是直接在局部变量slot上进行运算
  • a++ 和 ++a 的区别是先执行**iload(读取)**还是先执行iinc
    • a++ 是先 iload 再 iinc
    • ++a 是先 iinc 再 iload

结论：

图解过长，计算出后观看视频验证答案

https://www.bilibili.com/video/BV1yE411Z7AP?p=112

3.2.4 条件判断

几点说明：

  • byte，short，char 都会按 int 比较，因为操作数栈都是 4 字节
  • goto 用来进行跳转到指定行号的字节码

源码：

1
2
3
4
5
6
7
8
9
10
public class Demo3_3 {
    public static void main(String[] args) {
        int a = 0;
        if(a == 0) {
        	a = 10;
        } else {
        	a = 20;
        }
    }
}

字节码code

1
2
3
4
5
6
7
8
9
10
0: iconst_0	 //把 0 压入操作数栈 （比较小的数 -1到5用iconst）
1: istore_1  //把这个 0 赋值给 a（局部变量1号位） 即 a = 0;
2: iload_1  //把局部变量表1号位的值读取到操作数栈
3: ifne 12  // 判断 如果不成立（这里即a不等于0）则跳转到12行，如果等于则继续往下
6: bipush 10  //把 10 放入操作数栈
8: istore_1   //把 10 赋值给 a
9: goto 15   // 跳转到15行
12: bipush 20 //把 20 放入操作数栈
14: istore_1 //把 20 赋值给 a
15: return

3.2.5 循环控制

其实循环控制还是前面介绍的那些指令，例如 while 循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Demo3_4 {
    public static void main(String[] args) {
        int a = 0;
        while (a < 10) {
        	a++;
        }
    }
}

code:
0: iconst_0
1: istore_1
2: iload_1
3: bipush 10
5: if_icmpge 14
8: iinc 1, 1
11: goto 2
14: return

再比如 do while 循环：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Demo3_5 {
    public static void main(String[] args) {
        int a = 0;
        do {
            a++;
        } while (a < 10);
    }
}

code:
0: iconst_0
1: istore_1
2: iinc 1, 1
5: iload_1
6: bipush 10
8: if_icmplt 2
11: return

最后再看看 for 循环：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Demo3_6 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
        
        }
    }
}

0: iconst_0
1: istore_1
2: iload_1
3: bipush 10
5: if_icmpge 14
8: iinc 1, 1
11: goto 2
14: return

3.2.6 练习-分析x=0（经典）

请从字节码角度分析，下列代码运行的结果：

1
2
3
4
5
6
7
8
9
10
11
public class Demo2 {
	public static void main(String[] args) {
		int i=0;
		int x=0;
		while(i<10) {
			x = x++;
			i++;
		}
		System.out.println(x); //接过为0
	}
}

为什么最终的x结果为0呢？ 通过分析字节码指令即可知晓:

code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
0: iconst_0	//准备一个常数0
1: istore_1	//将常数0放入局部变量表的1号槽位 i=0
2: iconst_0	//准备一个常数0
3: istore_2	//将常数0放入局部变量的2号槽位 x=0	
4: 
5: bipush        10	//将数字10放入操作数栈中，此时操作数栈中有2个数
7: if_icmpge     21	//比较操作数栈中的两个数，如果下面的数大于上面的数，就跳转到21。这里的比较是将两个数做减法。因为涉及运算操作，所以会将两个数弹出操作数栈来进行运算。运算结束后操作数栈为空
10: iload_2		//将局部变量2号槽位的数放入操作数栈中，放入的值是0
11: iinc          2, 1	//将局部变量2号槽位的数加1，自增后，槽位中的值为1
14: istore_2	//将操作数栈中的数放入到局部变量表的2号槽位，2号槽位的值又变为了0
15: iinc          1, 1 //1号槽位的值自增1
18: goto          4 //跳转到第4条指令
21: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
24: iload_2
25: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
28: return

简单图解分析（不包含对循环的判断，对循环的判断详情在上面的注释）

因为是循环嘛，就简单的解释下：

1
2
3
4
5
6
7
8
9
x = 0;
x = x++;

code:
0: iconst_0	//准备一个常数0
1: istore_1	//将常数0放入局部变量表的1号槽位 x=0
2: iload_1		//将局部变量表1号槽位的数放入操作数栈中
3: iinc          1, 1	//将局部变量1号槽位的数加1，自增后，槽位中的值为1
4: istore_1	//将操作数栈中的数放入到局部变量表的1号槽位，1号槽位的值又变为了0; 即赋值操作 x = ，赋值操作是赋值操作数栈里的，具体看3.2.2.4中

图解：分析x = 0 | ProcessOn免费在线作图,在线流程图,在线思维导图 |

3.2.7 构造方法

3.2.7.1 cinit()V

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Demo3 {
	static int i = 10;

	static {
		i = 20;
	}

	static {
		i = 30;
	}

	public static void main(String[] args) {
		System.out.println(i); //结果为30
	}
}Copy

编译器会按从上至下的顺序，收集所有 static 静态代码块和静态成员赋值的代码，合并为一个特殊的方法 cinit()V ：

1
2
3
4
5
6
7
8
stack=1, locals=0, args_size=0
         0: bipush        10
         2: putstatic     #3                  // Field i:I 变量赋值
         5: bipush        20ja
         7: putstatic     #3                  // Field i:I
        10: bipush        30
        12: putstatic     #3                  // Field i:I
        15: return

3.2.7.2 init()V

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Demo4 {
	private String a = "s1";

	{
		b = 20;
	}

	private int b = 10;

	{
		a = "s2";
	}

	public Demo4(String a, int b) {
		this.a = a;
		this.b = b;
	}

	public static void main(String[] args) {
		Demo4 d = new Demo4("s3", 30);
		System.out.println(d.a);
		System.out.println(d.b);
	}
}
  • 编译器会按从上至下的顺序，收集所有 {} 代码块和成员变量赋值的代码，形成新的构造方法，但原始构造方法内的代码总是在后
  • 如果有多个构造函数，则会一一对应生成多个
  • 简单说：执行顺序：静态代码块 > 代码块 > 构造方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public cn.itcast.jvm.t3.bytecode.Demo3_8_2(java.lang.String, int);
    descriptor: (Ljava/lang/String;I)V
    flags: ACC_PUBLIC
    Code:
        stack=2, locals=3, args_size=3
        0: aload_0
        1: invokespecial #1 // super.<init>()V
        4: aload_0
        5: ldc #2 // <- "s1"
        7: putfield #3 // -> this.a
        10: aload_0
        11: bipush 20 // <- 20
        13: putfield #4 // -> this.b
        16: aload_0
        17: bipush 10 // <- 10
        19: putfield #4 // -> this.b
        22: aload_0
        23: ldc #5 // <- "s2"
        25: putfield #3 // -> this.a
        28: aload_0 // ------------------------------
        29: aload_1 // <- slot 1(a) "s3" |
        30: putfield #3 // -> this.a |
        33: aload_0 |
        34: iload_2 // <- slot 2(b) 30 |
        35: putfield #4 // -> this.b --------------------
        38: return
    LineNumberTable: ...
    LocalVariableTable:
    Start Length Slot Name Signature
    0 39 0 this Lcn/itcast/jvm/t3/bytecode/Demo3_8_2;
    0 39 1 a Ljava/lang/String;
    0 39 2 b I
    MethodParameters: ...

3.2.8 方法调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class Demo5 {
	public Demo5() {

	}

	private void test1() {

	}

	private final void test2() {

	}

	public void test3() {

	}

	public static void test4() {

	}

	public static void main(String[] args) {
		Demo5 demo5 = new Demo5();
		demo5.test1();
		demo5.test2();
		demo5.test3();
		Demo5.test4();
	}
}

不同方法在调用时，对应的虚拟机指令有所区别

  • 私有、构造、被final修饰的方法，在调用时都使用invokespecial指令
  • 普通成员方法在调用时，使用invokespecial指令。因为编译期间无法确定该方法的内容，只有在运行期间才能确定
  • 静态方法在调用时使用invokestatic指令
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Code:
      stack=2, locals=2, args_size=1
         0: new           #2                  // class com/Demo5 
         3: dup
         4: invokespecial #3                  // Method "<init>":()V
         7: astore_1
         8: aload_1
         9: invokespecial #4                  // Method test1:()V
        12: aload_1
        13: invokespecial #5                  // Method test2:()V
        16: aload_1
        17: invokevirtual #6                  // Method test3:()V
        20: invokestatic  #7                  // Method test4:()V
        23: returnCopy
  • new 是创建【对象】，给对象分配堆内存，执行成功会将【对象引用】压入操作数栈
  • dup 是赋值操作数栈栈顶的内容，本例即为【对象引用】，为什么需要两份引用呢，一个是要配合 invokespecial 调用该对象的构造方法 “init”:()V （会消耗掉栈顶一个引用），另一个要 配合 astore_1 赋值给局部变量
  • 终方法（final），私有方法（private），构造方法都是由 invokespecial 指令来调用，属于静态绑定
  • 普通成员方法是由 invokevirtual 调用，属于动态绑定，即支持多态 成员方法与静态方法调用的另一个区别是，执行方法前是否需要【对象引用】

3.2.9 多态的原理

ps: 实在不理解，仅摘抄笔记 https://www.bilibili.com/video/BV1yE411Z7AP?p=122

因为普通成员方法需要在运行时才能确定具体的内容，所以虚拟机需要调用invokevirtual指令

在执行invokevirtual指令时，经历了以下几个步骤

  • 先通过栈帧中对象的引用找到对象
  • 分析对象头，找到对象实际的Class
  • Class结构中有vtable，它在类加载的链接阶段就已经根据方法的重写规则生成好了
  • 查询vtable找到方法的具体地址
  • 执行方法的字节码

3.2.10 异常处理(面试问)

3.2.10.1 try-catch

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
 *代码
**/
public class Demo3_11_1 {
    public static void main(String[] args) {
        int i = 0;
        try {
        	i = 10;
        } catch (Exception e) {
        	i = 20;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
        stack=1, locals=3, args_size=1
            0: iconst_0
            1: istore_1
            2: bipush 10
            4: istore_1
            5: goto 12
            8: astore_2
            9: bipush 20
            11: istore_1
            12: return
        Exception table: //异常表，用来监测
        from    to target    type
            2    5      8    Class java/lang/Exception
        LineNumberTable: ...
        LocalVariableTable:
        Start Length Slot Name Signature
            9      3    2    e   Ljava/lang/Exception;
            0     13    0   args [Ljava/lang/String;
            2     11    1     i   I
        StackMapTable: ...
    MethodParameters: ...
}
  • 可以看到多出来一个 Exception table 的结构，[from, to) 是前闭后开（也就是检测2~4行）的检测范围，一旦这个范围内的字节码执行出现异常，则通过 type 匹配异常类型，如果一致，进入 target 所指示行号
  • 8行的字节码指令 astore_2 是将异常对象引用存入局部变量表的2号位置（为e）

3.2.10.2 多个single-catch

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Demo3_11_2 {
    public static void main(String[] args) {
        int i = 0;
        try {
        	i = 10;
        } catch (ArithmeticException e) {
        	i = 30;
        } catch (NullPointerException e) {
        	i = 40;
        } catch (Exception e) {
        	i = 50;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
        stack=1, locals=3, args_size=1
            0: iconst_0
            1: istore_1
            2: bipush 10
            4: istore_1
            5: goto 26
            8: astore_2
            9: bipush 30
            11: istore_1
            12: goto 26
            15: astore_2
            16: bipush 40
            18: istore_1
            19: goto 26
            22: astore_2
            23: bipush 50
            25: istore_1
            26: return
        Exception table:
        from   to   target   type
           2    5       8    Class java/lang/ArithmeticException
           2    5       15   Class java/lang/NullPointerException
           2    5       22   Class java/lang/Exception
        LineNumberTable: ...
        LocalVariableTable:
        Start    Length    Slot    Name    Signature
            9         3       2       e    Ljava/lang/ArithmeticException;
           16         3       2       e    Ljava/lang/NullPointerException;
           23         3       2       e    Ljava/lang/Exception;
            0        27       0      args  [Ljava/lang/String;
            2         25      1      i     I
        StackMapTable: ...
    MethodParameters: ...
  • 因为异常出现时，只能进入 Exception table 中一个分支，所以局部变量表 slot 2 位置被共用

3.2.10.3 multi-chtch的情况

  • 相当于多个single-catch的优化，把平级的异常写在一起
  • target都一样
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Demo3_11_3 {
    public static void main(String[] args) {
        try {
        	Method test = Demo3_11_3.class.getMethod("test");
        	test.invoke(null);
        } catch (NoSuchMethodException | IllegalAccessException |
        	InvocationTargetException e) {
        	e.printStackTrace();
        }
    }
    public static void test() {
        System.out.println("ok");
    }
}

3.2.10.4 finally

1
2
3
4
5
6
7
8
9
10
11
12
public class Demo3_11_4 {
    public static void main(String[] args) {
        int i = 0;
        try {
        	i = 10;
        } catch (Exception e) {
        	i = 20;
        } finally {
        	i = 30;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
        stack=1, locals=4, args_size=1
            0: iconst_0
            1: istore_1   // 0 -> i
            /**try块**/
            2: bipush 10  // try --------------------------------------
            4: istore_1   // 10 -> i                                  |
            /**try块执行完后，会执行finally**/                           |
            5: bipush 30  // finally                                  |
            7: istore_1   // 30 -> i                                  |
            8: goto 27    // return -----------------------------------
            /**catch块**/      
            11: astore_2  // catch Exceptin -> e 异常信息放入局部变量表的2号槽位
            12: bipush 20 //         								  |
            14: istore_1  // 20 -> i 								  |
            /**catch块执行完后，会执行finally**/                         |
            15: bipush 30 // finally 								  |
            17: istore_1  // 30 -> i 								  |
            18: goto 27   // return -----------------------------------
            /**出现异常，但未被Exception捕获，会抛出其他异常，这时也需要执行finally块中的代码**/   
            21: astore_3  // catch any -> slot 3 ----------------------
            22: bipush 30 // finally                                  |
            /**同上**/
            24: istore_1  // 30 -> i                                  |
            25: aload_3   // <- slot 3                                |
            26: athrow    // throw 抛出异常-----------------------------
            27: return
        Exception table:
            from to target type
            2    5   11    Class java/lang/Exception
            2    5   21    any // 剩余的异常类型，比如 Error
            11   15  21    any // 剩余的异常类型，比如 Error
        LineNumberTable: ...
        LocalVariableTable:
            Start Length Slot Name  Signature
            12    3      2     e     Ljava/lang/Exception;
            0     28     0     args [Ljava/lang/String;
            2     26     1     i     I
        StackMapTable: ...
    MethodParameters: ...

  • 可以看到 finally 中的代码被复制了 3 份，分别放入 try 流程，catch 流程以及 catch剩余的异常类型流程
  • 注意：虽然从字节码指令看来，每个块中都有finally块，但是finally块中的代码只会被执行一次

3.2.10.5 finally面试题

题一：finally中含有return
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Demo3 {
	public static void main(String[] args) {
		int i = Demo3.test();
		System.out.println(i);
	}

	public static int test() {
		int i;
		try {
			i = 10;
			return i;
		} finally {
			i = 20;
			return i;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static int test();
    descriptor: ()I
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
        stack=1, locals=2, args_size=0
            0: bipush 10 // <- 10 放入栈顶
            2: istore_0 // 10 -> slot 0 (从栈顶移除了)
            3: bipush 20 // <- 20 放入栈顶
            5: ireturn // 返回栈顶 int(20)
            6: astore_1 // catch any -> slot 1
            7: bipush 20 // <- 20 放入栈顶
            9: ireturn // 返回栈顶 int(20)
        Exception table:
            from to target type
               0  3     6   any
        LineNumberTable: ...
        StackMapTable: ...

所以结果为20

  • 由于 finally 中的 ireturn 被插入了所有可能的流程，因此返回结果肯定以finally的为准

  • 至于字节码中第 2 行，似乎没啥用，且留个伏笔，看下个例子

    • 实际上呢是istore_0后面还有iload_0、和istore_1 用来暂存返回值；

    • 这个时候临时变量表0号位和1号位都是 10，操作数栈为空

    • 然后执行finally，bipush 20后面起始还有，istore_0，iload_0

    • 这个时候呢临时变量表0号位是 10，局部变量表栈顶是20

    • 最后ireturn 20

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      完整code 
       0: bipush        10
       2: istore_0
       3: iload_0
       4: istore_1  //暂存返回值
       5: bipush        20
       7: istore_0
       8: iload_0
       9: ireturn	//ireturn会返回操作数栈顶的整型值20
      //如果出现异常，还是会执行finally块中的内容，没有抛出异常
      10: astore_2
      11: bipush        20
      13: istore_0
      14: iload_0
      15: ireturn	//这里没有athrow了，也就是如果在finally块中如果有返回操作的话，且try块中出现异常，会吞掉异常！

  • 跟上例中的 finally 相比，发现没有 athrow 了，这告诉我们：如果在 finally 中出现了 return，会吞掉异常

  • 所以不要在finally中进行返回操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Demo3 {
   public static void main(String[] args) {
      int i = Demo3.test();
      //最终结果为20
      System.out.println(i);
   }

   public static int test() {
      int i;
      try {
         i = 10;
         //这里应该会抛出异常
         i = i/0;
         return i;
      } finally {
         i = 20;
         return i;
      }
   }
}

会发现打印结果为20，并未抛出异常

题二：finally中不含有return
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Demo4 {
	public static void main(String[] args) {
		int i = Demo4.test();
		System.out.println(i);
	}

	public static int test() {
		int i = 10;
		try {
			return i;
		} finally {
			i = 20;
		}
	}
}Copy

对应字节码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Code:
     stack=1, locals=3, args_size=0
        0: bipush        10
        2: istore_0 //赋值给i 10
        3: iload_0	//加载到操作数栈顶
        4: istore_1 //加载到局部变量表的1号位置
        5: bipush        20
        7: istore_0 //赋值给i 20
        8: iload_1 //加载局部变量表1号位置的数10到操作数栈
        9: ireturn //返回操作数栈顶元素 10
       10: astore_2
       11: bipush        20
       13: istore_0
       14: aload_2 //加载异常
       15: athrow //抛出异常
     Exception table:
        from    to  target type
            3     5    10   any

即上道题中卖的关子，也解释了；第3，4行的意图就是在1号位上保存好这个return，因为后面还有finally的代码要执行

答案为10

3.2.11 synchronized

1
2
3
4
5
6
7
8
9
10
11
public class Demo5 {
	public static void main(String[] args) {
		int i = 10;
		Lock lock = new Lock();
		synchronized (lock) {
			System.out.println(i);
		}
	}
}

class Lock{}

对应字节码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Code:
     stack=2, locals=5, args_size=1
        0: bipush        10
        2: istore_1
        3: new           #2                  // class com/nyima/JVM/day06/Lock
        6: dup //复制一份，放到操作数栈顶，用于构造函数消耗
        7: invokespecial #3                  // Method com/nyima/JVM/day06/Lock."<init>":()V
       10: astore_2 //剩下的一份放到局部变量表的2号位置
       11: aload_2 //加载到操作数栈
       12: dup //复制一份，放到操作数栈，用于加锁时消耗
       13: astore_3 //将操作数栈顶元素弹出，暂存到局部变量表的三号槽位。这时操作数栈中有一份对象的引用
       14: monitorenter //加锁
       //锁住后代码块中的操作    
       15: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
       18: iload_1
       19: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
       //加载局部变量表中三号槽位对象的引用，用于解锁    
       22: aload_3    
       23: monitorexit //解锁
       24: goto          34
       //异常操作    
       27: astore        4
       29: aload_3
       30: monitorexit //解锁
       31: aload         4
       33: athrow
       34: return
     //可以看出，无论何时出现异常，都会跳转到27行，将异常放入局部变量中，并进行解锁操作，然后加载异常并抛出异常。      
     Exception table:
        from    to  target type
           15    24    27   any
           27    31    27   any

3.3 编译期处理

所谓的 语法糖 ，其实就是指 java 编译器把 *.java 源码编译为 *.class 字节码的过程中，自动生成和转换的一些代码，主要是为了减轻程序员的负担，算是 java 编译器给我们的一个额外福利

注意，以下代码的分析，借助了 javap 工具，idea 的反编译功能，idea 插件 jclasslib 等工具。另外， 编译器转换的结果直接就是 class 字节码，只是为了便于阅读，给出了 几乎等价 的 java 源码方式，并不是编译器还会转换出中间的 java 源码，切记。

引用了大佬的笔记：

https://nyimac.gitee.io/2020/07/03/JVM%E5%AD%A6%E4%B9%A0/

3.3.1 默认构造函数

1
2
3
public class Candy1 {

}

经过编译期优化后

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

3.3.2 自动拆装箱

基本类型和其包装类型的相互转换过程，称为拆装箱

在JDK 5以后，它们的转换可以在编译期自动完成

1
2
3
4
5
6
public class Demo2 {
   public static void main(String[] args) {
      Integer x = 1;
      int y = x;
   }
}

转换过程如下

1
2
3
4
5
6
7
8
public class Demo2 {
   public static void main(String[] args) {
      //基本类型赋值给包装类型，称为装箱
      Integer x = Integer.valueOf(1);
      //包装类型赋值给基本类型，称谓拆箱
      int y = x.intValue();
   }
}

3.3.3 泛型集合取值

泛型也是在 JDK 5 开始加入的特性，但 java 在编译泛型代码后会执行 泛型擦除 的动作，即泛型信息在编译为字节码之后就丢失了，实际的类型都当做了 Object 类型来处理：

1
2
3
4
5
6
7
public class Demo3 {
   public static void main(String[] args) {
      List<Integer> list = new ArrayList<>();
      list.add(10);
      Integer x = list.get(0);
   }
}

对应字节码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Code:
    stack=2, locals=3, args_size=1
       0: new           #2                  // class java/util/ArrayList
       3: dup
       4: invokespecial #3                  // Method java/util/ArrayList."<init>":()V
       7: astore_1
       8: aload_1
       9: bipush        10
      11: invokestatic  #4                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      //这里进行了泛型擦除，实际调用的是add(Objcet o)
      14: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z

      19: pop
      20: aload_1
      21: iconst_0
      //这里也进行了泛型擦除，实际调用的是get(Object o)   
      22: invokeinterface #6,  2            // InterfaceMethod java/util/List.get:(I)Ljava/lang/Object;
//这里进行了类型转换，将Object转换成了Integer
      27: checkcast     #7                  // class java/lang/Integer
      30: astore_2
      31: returnCopy

所以调用get函数取值时，有一个类型转换的操作

1
Integer x = (Integer) list.get(0);

如果要将返回结果赋值给一个int类型的变量，则还有自动拆箱的操作

1
int x = (Integer) list.get(0).intValue();

还好这些麻烦事都不用自己做。

3.3.4 可变参数

可变参数也是 JDK 5 开始加入的新特性：

1
2
3
4
5
6
7
8
9
10
11
public class Demo4 {
   public static void foo(String... args) {
      //将args赋值给arr，可以看出String...实际就是String[] 
      String[] arr = args;
      System.out.println(arr.length);
   }

   public static void main(String[] args) {
      foo("hello", "world");
   }
}

可变参数 String… args 其实是一个 String[] args ，从代码中的赋值语句中就可以看出来。 同 样 java 编译器会在编译期间将上述代码变换为：

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Demo4 {
   public Demo4 {}

    
   public static void foo(String[] args) {
      String[] arr = args;
      System.out.println(arr.length);
   }

   public static void main(String[] args) {
      foo(new String[]{"hello", "world"});
   }
}Copy

注意，如果调用的是foo()，即未传递参数时，等价代码为foo(new String[]{})，创建了一个空数组，而不是直接传递的null

3.3.5 foreach

仍是 JDK 5 开始引入的语法糖，数组的循环：

1
2
3
4
5
6
7
8
9
public class Demo5 {
	public static void main(String[] args) {
        //数组赋初值的简化写法也是一种语法糖。
		int[] arr = {1, 2, 3, 4, 5};
		for(int x : arr) {
			System.out.println(x);
		}
	}
}

编译器会帮我们转换为

1
2
3
4
5
6
7
8
9
10
11
public class Demo5 {
    public Demo5 {}

	public static void main(String[] args) {
		int[] arr = new int[]{1, 2, 3, 4, 5};
		for(int i=0; i<arr.length; ++i) {
			int x = arr[i];
			System.out.println(x);
		}
	}
}

如果是集合使用foreach

1
2
3
4
5
6
7
8
public class Demo5 {
   public static void main(String[] args) {
      List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
      for (Integer x : list) {
         System.out.println(x);
      }
   }
}

集合要使用foreach，需要该集合类实现了Iterable接口，因为集合的遍历需要用到迭代器Iterator，实际被编译器转换为迭代器的调用

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Demo5 {
    public Demo5 {}
    
   public static void main(String[] args) {
      List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
      //获得该集合的迭代器
      Iterator<Integer> iterator = list.iterator();
      while(iterator.hasNext()) {
         Integer x = iterator.next();
         System.out.println(x);
      }
   }
}

注意
foreach 循环写法，能够配合数组，以及所有实现了 Iterable 接口的集合类一起使用，

其中Iterable 用来获取集合的迭代器（ Iterator ）

3.3.6 switch字符串

从 JDK 7 开始，switch 可以作用于字符串和枚举类，这个功能其实也是语法糖，例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Demo6 {
   public static void main(String[] args) {
      String str = "hello";
      switch (str) {
         case "hello" :
            System.out.println("h");
            break;
         case "world" :
            System.out.println("w");
            break;
         default:
            break;
      }
   }
}

注意
switch 配合 String 和枚举使用时，变量不能为null，原因分析完语法糖转换后的代码应当自然清楚

会被编译器转换为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class Demo6 {
   public Demo6() {
      
   }
   public static void main(String[] args) {
      String str = "hello";
      int x = -1;
      //通过字符串的hashCode+value来判断是否匹配
      switch (str.hashCode()) {
         //hello的hashCode
         case 99162322 :
            //再次比较，因为字符串的hashCode有可能相等
            if(str.equals("hello")) {
               x = 0;
            }
            break;
         //world的hashCode
         case 11331880 :
            if(str.equals("world")) {
               x = 1;
            }
            break;
         default:
            break;
      }

      //用第二个switch在进行输出判断
      switch (x) {
         case 0:
            System.out.println("h");
            break;
         case 1:
            System.out.println("w");
            break;
         default:
            break;
      }
   }
}

过程说明：

  • 在编译期间，单个的switch被分为了两个

    • 第一个用来匹配字符串，并给x赋值

      • 字符串的匹配用到了字符串的hashCode，还用到了equals方法

      • 使用hashCode是为了提高比较效率，使用equals是防止有hashCode冲突（如BM和C.）

      • 第二个用来根据x的值来决定输出语句

      • 例如：

        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        38
        39
        40
        41
        42
        public class Candy6_2 {
            public static void choose(String str) {
                switch (str) {
                    case "BM": {
                        System.out.println("h");
                        break;
                    }
                    case "C.": {
                        System.out.println("w");
                        break;
                    }
                }
            }
        }

        /**
        **会被转换为
        **/

        public class Candy6_2 {
            public Candy6_2() {
            }
            public static void choose(String str) {
                byte x = -1;
                switch(str.hashCode()) {
                case 2123: // hashCode 值可能相同，需要进一步用 equals 比较
                	if (str.equals("C.")) {
                		x = 1;
                	} else if (str.equals("BM")) {
                		x = 0;
                	}
                default:
                    switch(x) {
                    case 0:
                    	System.out.println("h");
                    	break;
                    case 1:
                    	System.out.println("w");
                    }
                }
            }
        }

3.3.7 switch枚举

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Demo7 {
   public static void main(String[] args) {
      SEX sex = SEX.MALE;
      switch (sex) {
         case MALE:
            System.out.println("man");
            break;
         case FEMALE:
            System.out.println("woman");
            break;
         default:
            break;
      }
   }
}

enum SEX {
   MALE, FEMALE;
}

编译器中执行的代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class Demo7 {
   /**     
    * 定义一个合成类（仅 jvm 使用，对我们不可见）     
    * 用来映射枚举的 ordinal 与数组元素的关系     
    * 枚举的 ordinal 表示枚举对象的序号，从 0 开始     
    * 即 MALE 的 ordinal()=0，FEMALE 的 ordinal()=1     
    */ 
   static class $MAP {
      //数组大小即为枚举元素个数，里面存放了case用于比较的数字
      static int[] map = new int[2];
      static {
         //ordinal即枚举元素对应所在的位置，MALE为0，FEMALE为1
         map[SEX.MALE.ordinal()] = 1;
         map[SEX.FEMALE.ordinal()] = 2;
      }
   }

   public static void main(String[] args) {
      SEX sex = SEX.MALE;
      //将对应位置枚举元素的值赋给x，用于case操作
      int x = $MAP.map[sex.ordinal()];
      switch (x) {
         case 1:
            System.out.println("man");
            break;
         case 2:
            System.out.println("woman");
            break;
         default:
            break;
      }
   }
}

3.3.8 枚举类

JDK 7 新增了枚举类，以前面的性别枚举为例：

1
2
3
enum SEX {
   MALE, FEMALE;
}

转换后的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public final class Sex extends Enum<Sex> {   
   //对应枚举类中的元素
   public static final Sex MALE;    
   public static final Sex FEMALE;    
   private static final Sex[] $VALUES;
   
    static {       
    	//调用构造函数，传入枚举元素的值及ordinal
    	MALE = new Sex("MALE", 0);    
        FEMALE = new Sex("FEMALE", 1);   
        $VALUES = new Sex[]{MALE, FEMALE}; 
   }
 	
   //调用父类中的方法
    private Sex(String name, int ordinal) {     
        super(name, ordinal);    
    }
   
    public static Sex[] values() {  
        return $VALUES.clone();  
    }
    public static Sex valueOf(String name) { 
        return Enum.valueOf(Sex.class, name);  
    } 
   
}Copy

3.3.9 try-with-resources

https://www.bilibili.com/video/BV1yE411Z7AP?p=140

3.3.10 方法重写时的桥接方法

我们都知道，方法重写时对返回值分两种情况：

  • 父子类的返回值完全一致
  • 子类返回值可以是父类返回值的子类（比较绕口，见下面的例子）
1
2
3
4
5
6
7
8
9
10
11
12
13
class A {
    public Number m() {
    	return 1;
    }
}
class B extends A {
    @Override
    // 子类 m 方法的返回值是 Integer 是父类 m 方法返回值 Number 的子类
    public Integer m() {
    	return 2;
    }
}

对于子类，java 编译器会做如下处理：

1
2
3
4
5
6
7
8
9
10
class B extends A {
    public Integer m() {
    	return 2;
    }
    // 此方法才是真正重写了父类 public Number m() 方法
    public synthetic bridge Number m() {
        // 调用 public Integer m()
        return m();
    }
}

其中桥接方法比较特殊，仅对 java 虚拟机可见，并且与原来的 public Integer m() 没有命名冲突，可以
用下面反射代码来验证：

1
2
3
4
5
6
7
for (Method m : B.class.getDeclaredMethods()) {
	System.out.println(m);
}

//会输出
public java.lang.Integer test.candy.B.m()
public java.lang.Number test.candy.B.m()

3.3.11 匿名内部类

1
2
3
4
5
6
7
8
9
10
public class Demo8 {
   public static void main(String[] args) {
      Runnable runnable = new Runnable() {
         @Override
         public void run() {
            System.out.println("running...");
         }
      };
   }
}Copy

转换后的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Demo8 {
   public static void main(String[] args) {
      //用额外创建的类来创建匿名内部类对象
      Runnable runnable = new Demo8$1();
   }
}

//创建了一个额外的类，实现了Runnable接口
final class Demo8$1 implements Runnable {
   public Demo8$1() {}

   @Override
   public void run() {
      System.out.println("running...");
   }
}Copy

如果匿名内部类中引用了局部变量

1
2
3
4
5
6
7
8
9
10
11
public class Demo8 {
   public static void main(String[] args) {
      int x = 1;
      Runnable runnable = new Runnable() {
         @Override
         public void run() {
            System.out.println(x);
         }
      };
   }
}

转化后代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Demo8 {
   public static void main(String[] args) {
      int x = 1;
      Runnable runnable = new Runnable() {
         @Override
         public void run() {
            System.out.println(x);
         }
      };
   }
}

final class Demo8$1 implements Runnable {
   //多创建了一个变量
   int val$x;
   //变为了有参构造器
   public Demo8$1(int x) {
      this.val$x = x;
   }

   @Override
   public void run() {
      System.out.println(val$x);
   }
}

3.4 类加载阶段(重要)

3.4.1 加载

  • 将类的字节码载入

    方法区

    （1.8后为元空间，在本地内存中）中，内部采用 C++ 的 instanceKlass 描述 java 类，它的重要 field 有：

    • _java_mirror 即 java 的类镜像，例如对 String 来说，它的镜像类就是 String.class，作用是把 klass 暴露给 java 使用
    • _super 即父类
    • _fields 即成员变量
    • _methods 即方法
    • _constants 即常量池
    • _class_loader 即类加载器
    • _vtable 虚方法表
    • _itable 接口方法

  • 如果这个类还有父类没有加载，先加载父类

  • 加载和链接可能是交替运行的

image-20220810223332427

  • instanceKlass 这样的【元数据】是存储在方法区（1.8 后的元空间内，而元空间又位于本地内存中），但 _java_mirror
    是存储在堆中
    • InstanceKlass和*.class(JAVA镜像类 _java_mirror)互相保存了对方的地址
    • 类的对象在对象头中保存了*.class的地址。让对象可以通过其找到方法区中的instanceKlass，从而获取类的各种信息

3.4.2 链接

3.4.2.1 验证

验证类是否符合 JVM规范，安全性检查

例如：

用 UE 等支持二进制的编辑器修改 HelloWorld.class 的魔数（3.1.1），在控制台运行

image-20220810230057883

3.4.2.2 准备

为 static 变量分配空间，设置默认值

  • static变量在JDK 7以前是存储与instanceKlass末尾。但在JDK 7以后就存储在_java_mirror末尾了（即堆中）

  • static变量在分配空间和赋值是在两个阶段完成的。分配空间在准备阶段完成，赋值在初始化阶段完成

    • 如果 static 变量是 final 的基本类型，以及字符串常量，那么编译阶段值就确定了，赋值在准备阶段完成

    • 如果 static 变量是 final 的，但属于引用类型（比如 new Object()），那么赋值也会在初始化阶段完成

3.4.2.3 解析

  • 将常量池中的符号引用解析为直接引用
    • 符号引用：仅仅是个符号，不知道这个类或者方法、属性具体在内存的哪个位置
    • 直接引用：知道这个类或者方法、属性具体在内存的哪个位置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package cn.itcast.jvm.t3.load;
/**
* 解析的含义
*/
public class Load2 {
    public static void main(String[] args) throws ClassNotFoundException,IOException {
        ClassLoader classloader = Load2.class.getClassLoader();
        // loadClass 方法不会导致类的解析和初始化
        Class<?> c = classloader.loadClass("cn.itcast.jvm.t3.load.C");
        // new C(); new会导致类的解析和初始化
        System.in.read();
    }
}

class C {
	D d = new D();
}

class D {
    
}

3.4.3 初始化

初始化即调用 ()V ，虚拟机会保证这个类的『构造方法』的线程安全

  • clinit()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static{}块）中的语句合并产生的
    • 所以验证类是否被初始化，可以看该类的静态代码块是否被执行

3.4.3.1 发生时机

类的初始化的懒惰的，以下情况会初始化

  • main 方法所在的类，总会被首先初始化
  • 首次访问这个类的静态变量或静态方法时
  • 子类初始化，如果父类还没初始化，会引发
  • 子类访问父类的静态变量，只会触发父类的初始化
  • Class.forName
  • new 会导致初始化

以下情况不会初始化

  • 访问类的 static final 静态常量（基本类型和字符串）
  • 类对象.class 不会触发初始化
  • 创建该类对象的数组
  • 类加载器的.loadClass方法
  • Class.forNamed的参数2为false时

如下代码验证

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package cn.itcast.jvm.t3.load;

import java.io.IOException;

public class Load3 {
    static {
        System.out.println("main init");
    }
    public static void main(String[] args) throws ClassNotFoundException, IOException {
//        // 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.load.B");
//        // 5. 不会初始化类 B，但会加载 B、A
//        ClassLoader c2 = Thread.currentThread().getContextClassLoader();
//        Class.forName("cn.itcast.jvm.t3.load.B", false, c2);
        System.in.read();


//        // 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.load.B");
    }
}

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");
    }
}

3.4.4 练习

3.4.4.1 练习一

从字节码分析，使用 a，b，c 这三个常量是否会导致 E 初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package cn.itcast.jvm.t3.load;

public class Load4 {
    public static void main(String[] args) {
        System.out.println(E.a);
        System.out.println(E.b);
        System.out.println(E.c);

    }
}

class E {
    public static final int a = 10;
    public static final String b = "hello";
    public static final Integer c = 20;  // Integer.valueOf(20)
    static {
        System.out.println("init E");
    }
}

答案：a，b不会，c会
因为a和b都属于类的 static final 静态常量（基本类型和字符串）
c的Integer是包装类型 会用语法糖执行Integer.valueOf(20) 把 20 这个基本类型转换成Integer

3.4.4.2 练习二

完成懒惰初始化单例模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package cn.itcast.jvm.t3.load;

public class Load9 {
    public static void main(String[] args) {
//        Singleton.test();
        Singleton.getInstance();
    }

}

class Singleton {

    public static void test() {
        System.out.println("test");
    }
    
    //构造方法私有
    private Singleton() {}

    //静态内部类中保存单例，静态内部类的好处就是可以访问外部类的资源，比如构造方法和方法（私有的也可访问）
    private static class LazyHolder{
        private static final Singleton SINGLETON = new Singleton();
        static {
            System.out.println("lazy holder init");//用于验证是否初始化
        }
    }
    
	// 第一次调用 getInstance 方法，才会导致内部类加载和初始化其静态成员
    public static Singleton getInstance() {
        return LazyHolder.SINGLETON;
    }
}

静态内部类中保存单例，静态内部类的好处就是可以访问外部类的资源，比如构造方法和方法（私有的也可访问）

以上的实现特点是：

  • 懒惰实例化
  • 初始化时的线程安全是有保障的
  • 完美(哈哈哈哈哈)

3.5 类加载器

3.5.1 类与类加载器

类加载器虽然只用于实现类的加载动作，但它在Java程序中起到的作用却远超类加载阶段

对于任意一个类，都必须由加载它的类加载器和这个类本身一起共同确立其在Java虚拟机中的唯一性，每一个类加载器，都拥有一个独立的类名称空间。这句话可以表达得更通俗一些：比较两个类是否“相等”，只有在这两个类是由同一个类加载器加载的前提下才有意义，否则，即使这两个类来源于同一个Class文件，被同一个Java虚拟机加载，只要加载它们的类加载器不同，那这两个类就必定不相等

以JDK 8为例

名称 加载的类 说明
Bootstrap ClassLoader（启动类加载器） JAVA_HOME/jre/lib 无法直接访问
Extension ClassLoader(拓展类加载器) JAVA_HOME/jre/lib/ext 上级为Bootstrap，显示为null
Application ClassLoader(应用程序类加载器) classpath 上级为Extension
自定义类加载器 自定义 上级为Application

  • 各司其职，每个加载器只加载自己负责目录下的所有的类

  • 层级关系：

    • 自底向上询问有没有加载过，例如String类

      • 自定义类加载器 问 应用程序类加载器有没有加载String，如果没有，继续往上，到达启动类加载器中已经加载过了，则String不用再加载

    • 如果都没有加载过则由最顶级开始往下，查找自己负责的目录下能不能加载；例如自定义的Student类

      • 先往上询问，肯定都没有加载过，然后再一步步下来到应用程序加载器

3.5.2 启动类加载器

可通过在控制台输入指令，使得自定义类被启动类加器加载

在正确的路径下执行：java -Xbootclasspath/a:.cn.itcast.jvm.t3.load.Load5

3.5.3 扩展类加载类

如果classpath和 JAVA_HOME/jre/lib/ext 下有同名类，加载时会使用拓展类加载器加载。当应用程序类加载器发现拓展类加载器已将该同名类加载过了，则不会再次加载

3.5.4 双亲委派模式

所谓的双亲委派，就是指调用类加载器的 loadClass 方法时，查找类的规则

注意
这里的双亲，翻译为上级似乎更为合适，因为它们并没有继承关系

loadClass源码

递归查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException
{
    synchronized (getClassLoadingLock(name)) {
        // 首先查找该类是否已经被该类加载器加载过了
        Class<?> c = findLoadedClass(name);
        //如果没有被加载过
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                //看是否被它的上级加载器加载过了 Extension的上级是Bootstarp，但它显示为null
                if (parent != null) {
                    //有上级，就委派上级 这里是递归
                    c = parent.loadClass(name, false);
                } else {
                    //如果没有上级了（ExtClassLoader），则委派BootstrapClassLoader 看是否被启动类加载器加载过
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
                //捕获异常，但不做任何处理
            }

            if (c == null) {
                //如果还是没有找到，先让拓展类加载器调用findClass方法去找到该类，如果还是没找到，就抛出异常
                long t1 = System.nanoTime();
                c = findClass(name);

                // 记录时间
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

为了防止内存中出现多个相同的字节码；因为如果没有双亲委派的话，用户就可以自己定义一个java.lang.String类，那么就无法保证类的唯一性。

3.5.5 自定义加载器

3.5.5.1 使用场景

  • 想加载非 classpath 随意路径中的类文件
  • 通过接口来使用实现，希望解耦时，常用在框架设计
  • 这些类希望予以隔离，不同应用的同名类都可以加载，不冲突，常见于 tomcat 容器

3.5.5.2 步骤

  • 继承ClassLoader父类
  • 要遵从双亲委派机制，重写 findClass 方法
    • 不是重写loadClass方法，否则不会走双亲委派机制
  • 读取类文件的字节码
  • 调用父类的 defineClass 方法来加载类
  • 使用者调用该类加载器的 loadClass 方法

3.6 破坏双亲委派

那怎么打破双亲委派模型？

自定义类加载器，继承ClassLoader类，重写loadClass方法和findClass方法。

列举一些你知道的打破双亲委派机制的例子，为什么要打破？

  • JNDI 通过引入线程上下文类加载器，可以在 Thread.setContextClassLoader 方法设置，默认是应用程序类加载器，来加载 SPI 的代码。有了线程上下文类加载器，就可以完成父类加载器请求子类加载器完成类加载的行为。打破的原因，是为了 JNDI 服务的类加载器是启动器类加载，为了完成高级类加载器请求子类加载器（即上文中的线程上下文加载器）加载类。

  • Tomcat，应用的类加载器优先自行加载应用目录下的 class，并不是先委派给父加载器，加载不了才委派给父加载器。

    tomcat之所以造了一堆自己的classloader，大致是出于下面三类目的：

    • 对于各个 webapp中的 class和 lib，需要相互隔离，不能出现一个应用中加载的类库会影响另一个应用的情况，而对于许多应用，需要有共享的lib以便不浪费资源。
    • 与 jvm一样的安全性问题。使用单独的 classloader去装载 tomcat自身的类库，以免其他恶意或无意的破坏；
    • 热部署。

    tomcat类加载器如下图：

    img

  • OSGi，实现模块化热部署，为每个模块都自定义了类加载器，需要更换模块时，模块与类加载器一起更换。其类加载的过程中，有平级的类加载器加载行为。打破的原因是为了实现模块热替换。

  • JDK 9，Extension ClassLoader 被 Platform ClassLoader 取代，当平台及应用程序类加载器收到类加载请求，在委派给父加载器加载前，要先判断该类是否能够归属到某一个系统模块中，如果可以找到这样的归属关系，就要优先委派给负责那个模块的加载器完成加载。打破的原因，是为了添加模块化的特性。

3.7 运行期优化

3.7.1 即时编译

3.7.1.1分层编译

JVM 将执行状态分成了 5 个层次：

  • 0层：解释执行，用解释器将字节码翻译为机器码
  • 1层：使用 C1 即时编译器编译执行（不带 profiling）
  • 2层：使用 C1 即时编译器编译执行（带基本的profiling）
  • 3层：使用 C1 即时编译器编译执行（带完全的profiling）
  • 4层：使用 C2 即时编译器编译执行

profiling 是指在运行过程中收集一些程序执行状态的数据，例如【方法的调用次数】，【循环的 回边次数】等

即时编译器（JIT）与解释器的区别
  • 解释器
    • 将字节码解释为机器码，下次即使遇到相同的字节码，仍会执行重复的解释
    • 是将字节码解释为针对所有平台都通用的机器码
  • 即时编译器
    • 将一些字节码编译为机器码，并存入 Code Cache，下次遇到相同的代码，直接执行，无需再编译
    • 根据平台类型，生成平台特定的机器码

对于大部分的不常用的代码，我们无需耗费时间将其编译成机器码，而是采取解释执行的方式运行；另一方面，对于仅占据小部分的热点代码，我们则可以将其编译成机器码，以达到理想的运行速度。 执行效率上简单比较一下 Interpreter < C1 < C2，总的目标是发现热点代码（hotspot名称的由 来），并优化这些热点代码（例如循环1000次 new Obkect对象，一定次数之后，就会把new Object()编译成机器码，提高效率）

逃逸分析

逃逸分析（Escape Analysis）简单来讲就是，Java Hotspot 虚拟机可以分析新创建对象的使用范围，并决定是否在 Java 堆上分配内存的一项技术（例如上述，1000个Object对象循环创建，但是从来没用过，就会在一段时间后发生逃逸，修改字节码，后续使它实际上没有被创建）

逃逸分析的 JVM 参数如下：

  • 开启逃逸分析：-XX:+DoEscapeAnalysis
  • 关闭逃逸分析：-XX:-DoEscapeAnalysis
  • 显示分析结果：-XX:+PrintEscapeAnalysis

逃逸分析技术在 Java SE 6u23+ 开始支持，并默认设置为启用状态，可以不用额外加这个参数

3.7.2 方法内联

3.7.2.1 内联函数

内联函数就是在程序编译时，编译器将程序中出现的内联函数的调用表达式用内联函数的函数体来直接进行替换

C++是否为内联函数由自己决定，Java由编译器决定。Java不支持直接声明为内联函数的，如果想让他内联，你只能够向编译器提出请求: 关键字final修饰 用来指明那个函数是希望被JVM内联的，如

1
2
3
public final void doSomething() {  
        // to do something  
}

总的来说，一般的函数都不会被当做内联函数，只有声明了final后，编译器才会考虑是不是要把你的函数变成内联函数

JVM内建有许多运行时优化。首先短方法更利于JVM推断。流程更明显，作用域更短，副作用也更明显。如果是长方法JVM可能直接就跪了。

3.7.2.1 举例

1
2
3
4
5
private static int square(final int i) {
	return i * i;
}

System.out.println(square(9));

如果发现 square 是热点方法，并且长度不太长时，会进行内联，所谓的内联就是把方法内代码拷贝、
粘贴到调用者的位置：

1
System.out.println(9 * 9);

还能够进行常量折叠（constant folding）的优化(因为计算结果始终都是81，就当成一个常量看)

1
System.out.println(81);

4. 内存模型

听说这部分结合juc并发学习更好，学成后更新^_^

Java
#Java #JVM
jvm学习
https://blog.gutaicheng.top/2022/08/06/JVM学习/
作者
GuTaicheng
发布于
2022年8月6日
许可协议