JVM 类加载、堆、栈等

最新推荐文章于 2024-08-12 08:00:00 发布

oo于野

最新推荐文章于 2024-08-12 08:00:00 发布

阅读量762

点赞数

分类专栏： JVM学习

本文链接：https://blog.csdn.net/lucylala007/article/details/108255519

版权

JVM学习专栏收录该内容

11 篇文章 0 订阅

订阅专栏

snkstart@126.com

1.类加载子系统

1.类加载子系统作用

类加载子系统负责从文件系统或者网络中加载Class文件，class文件在文件开头有特定的文件标识；
ClassLoader只负责class文件的加载，至于它是否可以运行，则由Execution Engine决定
加载的类信息存放于一块成为方法区的内存空间。除了类信息之外，方法区还会存放运行时常量池信息，可能还包括字符串字面量和数字常量（这部分常量信息是Class文件中常量池部分的内存映射）

1.1类加载器ClassLoader角色

1.2加载

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

1.3 链接

验证：

目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求，保证被加载类的正确性，不会危害虚拟机自身安全。
主要包括四种验证，文件格式验证，源数据验证，字节码验证，符号引用验证。

准备

为类变量分配内存并且设置该类变量的默认初始值，即零值；
这里不包含用final修饰的static，因为final在编译的时候就会分配了，准备阶段会显式初始化；
之类不会为实例变量分配初始化，类变量会分配在方法去中，而实例变量是会随着对象一起分配到java堆中。

解析

将常量池内的符号引用转换为直接引用的过程。
事实上，解析操作网晚会伴随着jvm在执行完初始化之后再执行
符号引用就是一组符号来描述所引用的目标。符号应用的字面量形式明确定义在《java虚拟机规范》的class文件格式中。直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄
解析动作主要针对类或接口、字段、类方法、接口方法、方法类型等。对应常量池中的CONSTANT_Class_info/CONSTANT_Fieldref_info、CONSTANT_Methodref_info等。

1.4初始化

初始化阶段就是执行类构造器方法clinit（）的过程。
此方法不需要定义，是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并而来。

双亲委派机制

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

双亲委派机制工作原理

例

双亲委派机制的优势

避免类的重复加载
保护程序安全，防止核心API被随意篡改
- 自定义类：java.lang.String
- 自定义类：java.lang.MeDsh（java.lang包需要访问权限，阻止我们用包名自定义类）

沙箱安全机制

自定义String类，但是在加载自定义String类的时候回率先使用引导类加载器加载，而引导类加载器在加载过程中会先加载jdk自带的文件（rt.jar包中的java\lang\String.class）,报错信息说没有main方法就是因为加载的是rt.jar包中的String类。这样可以保证对java核心源代码的保护，这就是*沙箱安全机制*.

类的主动使用和被动使用

java程序对类的使用方式分为：主动使用和被动使用

主动使用，分为七种情况
- 创建类的实例
- 访问某各类或接口的静态变量，或者对静态变量赋值
- 调用类的静态方法
- 反射比如Class.forName(com.dsh.jvm.xxx)
- 初始化一个类的子类
- java虚拟机启动时被标明为启动类的类
- JDK 7 开始提供的动态语言支持：
  java.lang.invoke.MethodHandle实例的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic句柄对应的类没有初始化，则初始化
除了以上七种情况，其他使用java类的方式都被看作是对类的被动使用，都不会导致类的初始化。

并行和并发区别

并行和并发都可以是多个线程，这些线程如果能被多个cpu执行，就是并行。如果多个线程只能被一个cpu轮流切换执行，就是并发。

如果某个系统支持两个或者多个动作（Action）同时存在，那么这个系统就是一个并发系统。如果某个系统支持两个或者多个动作同时执行，那么这个系统就是一个并行系统。并发系统与并行系统这两个定义之间的关键差异在于**“存在”**这个词。

在并发程序中可以同时拥有两个或者多个线程。这意味着，如果程序在单核处理器上运行，那么这两个线程将交替地换入或者换出内存。这些线程是同时“存在”的——每个线程都处于执行过程中的某个状态。如果程序能够并行执行，那么就一定是运行在多核处理器上。此时，程序中的每个线程都将分配到一个独立的处理器核上，因此可以同时运行。

我相信你已经能够得出结论——“并行”概念是“并发”概念的一个子集。也就是说，你可以编写一个拥有多个线程或者进程的并发程序，但如果没有多核处理器来执行这个程序，那么就不能以并行方式来运行代码。因此，凡是在求解单个问题时涉及多个执行流程的编程模式或者执行行为，都属于并发编程的范畴。

/**
 * 1. 设置堆空间大小的参数
 * -Xms 用来设置堆空间（年轻代+老年代）的初始内存大小
 *      -X 是jvm的运行参数
 *      ms 是memory start
 * -Xmx 用来设置堆空间（年轻代+老年代）的最大内存大小
 *
 * 2. 默认堆空间的大小
 *    初始内存大小：物理电脑内存大小 / 64
 *             最大内存大小：物理电脑内存大小 / 4
 * 3. 手动设置：-Xms600m -Xmx600m
 *     开发中建议将初始堆内存和最大的堆内存设置成相同的值。
 *
 * 4. 查看设置的参数：方式一： jps   /  jstat -gc 进程id
 *                  方式二：-XX:+PrintGCDetails
 * @author shkstart  shkstart@126.com
 * @create 2020  20:15
 */

non-final的类变量

静态变量和类关联在一起，随着类的加载而加载，他们成为类数据在逻辑上的一部分
类变量被类的所有实例所共享，即使没有类实例你也可以访问它。

//以下代码不会报空指针异常

空对象调用静态变量不会报空指针异常

全局常量 static final 被声明为final的类变量的处理方法则不同，每个全局常量在编译的时候就被分配了。

通过反编译可知

static final 修饰的变量在编译阶段就已经显示化赋值写入进去了

static 修饰的变量则在链接中的准备阶段初始化赋值一直到初始化阶段才会显示化赋值

初始化阶段就是执行类构造器方法clinit（）的过程。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wTQLZ3jU-1598497193579)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1597974588933.png)]$

反编译

在这里插入图片描述

还可以将编译的字节码文件写入到.txt中 两个，命令都可以或者使用jclasslib bytecode viewer 插件

在这里插入图片描述

2.内存结构–堆

JVM运行时数据区

java虚拟机定了了若干种程序运行期间会使用到的运行时数据区，其中有一些会随着虚拟机启动而创建，随着虚拟机退出而销毁。另外一些则是与线程一一对应的，这些与线程对应的数据区域会随着线程开始和结束而创建和销毁。
如图，灰色的区域为单独线程私有的，红色的为多个线程共享的，即

每个线程：独立包括程序计数器、栈、本地栈
线程间共享：堆、堆外内存（方法区、永久代或元空间、代码缓存）
堆——堆是所有线程共享的，主要用来存储对象。其中，堆可分为：年轻代和老年代两块区域。使用NewRatio参数来设定比例。对于年轻代，一个Eden区和两个Suvivor区，使用参数SuvivorRatio来设定大小；
Java虚拟机栈/本地方法栈——线程私有的，主要存放局部变量表，操作数栈，动态链接和方法出口等；
程序计数器——同样是线程私有的，记录当前线程的行号指示器，为线程的切换提供保障；
方法区——线程共享的，主要存储类信息、常量池、静态变量、JIT编译后的代码等数据。方法区理论上来说是堆的逻辑组成部分；
运行时常量池——是方法区的一部分，用于存放编译期生成的各种字面量和符号引用；

Java6和6之前，常量池是存放在方法区（永久代）中的。

Java7，将常量池是存放到了堆中。

Java8之后，取消了整个永久代区域，取而代之的是元空间。运行时常量池和静态常量池存放在元空间中，而字符串常量池依然存放在堆中。

运行时常量池

常量池

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mpeEgiCQ-1598497193582)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1597977243585.png)]$

https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.3

几种在常量池内存储的数据类型包括：

数量值
字符串值
类引用
字段引用
方法引用

小结

常量池，可以看做是一张表，虚拟机指令根据这张常量表找到要执行的类名，方法名，参数类型、字面量等信息。

局部变量表的动态链接将符号引用转化为直接引用

在Java源文件被编译成字节码文件中时，所有的变量和方法引用都作为符号引用（symbolic Refenrence）保存在class文件的常量池里。比如：描述一个方法调用了另外的其他方法时，就是通过常量池中指向方法的符号引用来表示的，那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用

运行时常量池就是字节码(ClassFile)文件中的常量池经过类加载器加载好后创建的对应方法区中的运行时常量池

在这里插入图片描述

运行时常量池（ Runtime Constant Pool）是方法区的一部分。
常量池表（Constant Pool Table）是Class文件的一部分，用于存放编译期生成的各种字面量与符号引用，这部分内容将在类加载后存放到方法区(元空间)的运行时常量池中。
运行时常量池，在加载类和接口到虚拟机后，就会创建对应的运行时常量池。
JVM为每个已加载的类型（类或接口）都维护一个常量池。池中的数据项像数组项一样，是通过索引访问的。
运行时常量池中包含多种不同的常量，包括编译期就已经明确的数值字面量，也包括到运行期解析后才能够获得的方法或者字段引用。此时不再是常量池中的符号地址了，这里换为真实地址。
- 运行时常量池，相对于Class文件常量池的另一重要特征是：具备动态性。
  - String.intern()
运行时常量池类似于传统编程语言中的符号表（symbol table），但是它所包含的数据却比符号表要更加丰富一些。
当创建类或接口的运行时常量池时，如果构造运行时常量池所需的内存空间超过了方法区所能提供的最大值，则JVM会抛OutOfMemoryError异常。

方法区的垃圾收集主要回收两部分内容：常量池中废奔的常量和不再使用的类型

字符串常量池

首先明确：只有HotSpot才有永久代。 BEA JRockit、IBM J9等来说，是不存在永久代的概念的。原则上如何实现方法区属于虛拟机实现细节，不受《Java虚拟机规范》管束，并不要求统一。
Hotspot中方法区的变化：

jdk1.6及之前：有永久代（permanent generation），静态变量存放在永久代上
jdk1.7：有永久代，但已经逐步“去永久代”，字符串常量池、静态变量移除，保存在堆中
jdk1.8及之后： 无永久代，类型信息、字段、方法、常量保存在本地内存的元空间，但字符串常量池、静态变量仍在堆

在这里插入图片描述

堆空间和方法区

图解对象分配过程

为新对象分配内存是件非常严谨和复杂的任务，JVM的设计者们不仅需要考虑内存如何分配、在哪里分配的问题，并且由于内存分配算法与内存回收算法密切相关，所以还需要考虑GC执行完内存回收后是否会在内存空间中产生内存碎片。

new的对象先放伊甸园区。此区有大小限制。
当伊甸园的空间填满时，程序又需要创建对象，JVM的垃圾回收器将对伊甸园区进行垃圾回收（Minor GC),将伊甸园区中的不再被其他对象所引用的对象进行销毁。再加载新的对象放到伊甸园区
然后将伊甸园中的剩余对象移动到幸存者0区。
如果再次触发垃圾回收，此时上次幸存下来的放到幸存者0区的，如果没有回收，就会放到幸存者1区。
如果再次经历垃圾回收，此时会重新放回幸存者0区，接着再去幸存者1区。
啥时候能去养老区呢？可以设置次数。默认是15次。·可以设置参数：-XX:MaxTenuringThreshold=进行设置。
在养老区，相对悠闲。当老年区内存不足时，再次触发GC：Major GC，进行养老区的内存清理。
若养老区执行了Major GC之后发现依然无法进行对象的保存，就会产生OOM异常。
幸存者区是被动GC 它满了也不会触发GC 只有当Eden区满了触发GC连带处理幸存者区幸存者区是有可能直接晋升到养老区的

总结
针对幸存者s0,s1区：复制之后有交换，谁空谁是to
关于垃圾回收：频繁在新生区收集，很少在养老区收集，几乎不再永久区/元空间收集。

Minor GC、Major GC、Full GC

JVM在进行GC时，并非每次都针对上面三个内存区域（新生代、老年代、方法区）一起回收的，大部分时候回收都是指新生代。

针对hotSpot VM的实现，它里面的GC按照回收区域又分为两大种类型：一种是部分收集（Partial GC），一种是整堆收集（Full GC）

部分收集：不是完整收集整个Java堆的垃圾收集。其中又分为：
- 新生代收集（Minor GC/Young GC）：只是新生代(Eden\S0,S1)的垃圾收集
- 老年代收集（Major GC/Old GC）：只是老年代的垃圾收集
  - 目前，只有CMS GC会有单独收集老年代的行为
  - 注意，很多时候Major GC 会和 Full GC混淆使用，需要具体分辨是老年代回收还是整堆回收
- 混合收集（Mixed GC）：收集整个新生代以及部分老年代的垃圾收集
  - 目前，之后G1 GC会有这种行为
整堆收集（Full GC）：收集整个java堆和方法区的垃圾收集
年轻代GC（Minor GC）触发机制：
当年轻代空间不足时，就会触发Minor GC，这里的年轻代满指的是Eden代满，Survivor满不会引发GC.(每次Minor GC会清理年轻代的内存，Survivor是被动GC，不会主动GC)
- 因为Java队形大多都具备朝生夕灭的特性，所以Minor GC 非常频繁，一般回收速度也比较快，这一定义既清晰又利于理解。
Minor GC 会引发STW（Stop the World），暂停其他用户的线程，等垃圾回收结束，用户线程才恢复运行。
老年代GC(Major GC/Full GC)触发机制 :
指发生在老年代的GC,对象从老年代消失时，Major GC 或者 Full GC 发生了
- 出现了Major GC，经常会伴随至少一次的Minor GC（不是绝对的，在Parallel Scavenge 收集器的收集策略里就有直接进行Major GC的策略选择过程）
  - 也就是老年代空间不足时，会先尝试触发Minor GC。如果之后空间还不足，则触发Major GC
- Major GC速度一般会比Minor GC慢10倍以上，STW时间更长
- 如果Major GC后，内存还不足，就报OOM了
Full GC触发机制
- 触发Full GC执行的情况有以下五种
  - ①调用System.gc()时，系统建议执行Full GC，但是不必然执行
  - ②老年代空间不足
  - ③方法区空间不足
  - ④通过Minor GC后进入老年代的平均大小小于老年代的可用内存
  - ⑤由Eden区，Survivor S0（from）区向S1（to）区复制时，对象大小由于To Space可用内存，则把该对象转存到老年代，且老年代的可用内存小于该对象大小
- 说明：Full GC 是开发或调优中尽量要避免的，这样暂停时间会短一些

堆空间分代思想

为什么要把Java堆分代？不分代就不能正常工作了么

经研究，不同对象的生命周期不同。70%-99%的对象都是临时对象。
- 新生代：有Eden、Survivor构成（s0,s1 又称为from to），to总为空
- 老年代：存放新生代中经历多次依然存活的对象
其实不分代完全可以，分代的唯一理由就是优化GC性能。如果没有分代，那所有的对象都在一块，就如同把一个学校的人都关在一个教室。GC的时候要找到哪些对象没用，这样就会对堆的所有区域进行扫描，而很多对象都是朝生夕死的，如果分代的话，把新创建的对象放到某一地方，当GC的时候先把这块存储“朝生夕死”对象的区域进行回收，这样就会腾出很大的空间出来。

内存分配策略

如果对象在Eden出生并经过第一次Minor GC后依然存活，并且能被Survivor容纳的话，将被移动到Survivor空间中，把那个将对象年龄设为1.对象在Survivor区中每熬过一次MinorGC，年龄就增加一岁，当它的年龄增加到一定程度（默认15岁，其实每个JVM、每个GC都有所不同）时，就会被晋升到老年代中
- 对象晋升老年代的年龄阈值，可以通过选项 -XX：MaxTenuringThreshold来设置
针对不同年龄段的对象分配原则如下：
- 优先分配到Eden
- 大对象直接分配到老年代
  - 尽量避免程序中出现过多的大对象
- 长期存活的对象分配到老年代
- 动态对象年龄判断
  - 如果Survivor区中相同年龄的所有对象大小的总和大于Survivor空间的一半，年龄大于或等于该年龄的对象可以直接进入到老年代。无需等到MaxTenuringThreshold中要求的年龄
- 空间分配担保
  - -XX: HandlePromotionFailure

永久代和方法区以及元空间的关系

涉及到内存模型时，往往会提到永久代，那么它和方法区又是什么关系呢？《Java虚拟机规范》只是规定了有方法区这么个概念和它的作用，并没有规定如何去实现它。那么，在不同的 JVM 上方法区的实现肯定是不同的了。同时大多数用的JVM都是Sun公司的HotSpot。在HotSpot上把GC分代收集扩展至方法区，或者说使用永久代来实现方法区。因此，我们得到了结论，永久代是HotSpot的概念，方法区是Java虚拟机规范中的定义，是一种规范，而永久代是一种实现，一个是标准一个是实现。其他的虚拟机实现并没有永久带这一说法。在1.7之前在(JDK1.2 ~ JDK6)的实现中，HotSpot 使用永久代实现方法区，HotSpot 使用 GC分代来实现方法区内存回收，可以使用如下参数来调节方法区的大小:

-XX:PermSize
方法区初始大小
-XX:MaxPermSize
方法区最大大小超过这个值将会抛出OutOfMemoryError异常:java.lang.OutOfMemoryError:PermGen

对于Java8， HotSpots取消了永久代，那么是不是也就没有方法区了呢？当然不是，方法区是一个规范，规范没变，它就一直在。那么取代永久代的就是元空间。它可永久代有什么不同的？存储位置不同，永久代物理是是堆的一部分，和新生代，老年代地址是连续的，而元空间属于本地内存；存储内容不同，元空间存储类的元信息，静态变量和常量池等并入堆中。相当于永久代的数据被分到了堆和元空间中。

3.运行时数据区

栈的存储结构和运行原理

每个线程都有自己的栈，栈中的数据都是以**栈帧(Stack Frame)**的格式存在
在这个线程上正在执行的每个方法都对应各自的一个栈帧
栈帧是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据信息
JVM直接对java栈的操作只有两个，就是对栈帧的压栈和出栈，遵循先进后出/后进先出的和原则。
在一条活动线程中，一个时间点上，只会有一个活动的栈帧。即只有当前正在执行的方法的栈帧（栈顶栈帧）是有效的，这个栈帧被称为当前栈帧(Current Frame),与当前栈帧对应的方法就是当前方法（Current Frame）
执行引擎运行的所有字节码指令只针对当前栈帧进行操作
如果在该方法中调用了其他方法，对应的新的栈帧会被创建出来，放在栈的顶端，成为新的当前栈帧。
不同线程中所包含的栈帧是不允许相互引用的，即不可能在另一个栈帧中引用另外一个线程的栈帧
如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着，虚拟机会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧
Java方法有两种返回函数的方式，一种是正常的函数返回，使用return指令；另外一种是抛出异常。不管使用哪种方式，都会导致栈帧被弹出。

1.程序计数器（PC寄存器）

1.1 作用

PC寄存器是用来存储指向下一条指令的地址，也即将将要执行的指令代码。由执行引擎读取下一条指令。

它是一块很小的内存空间，几乎可以忽略不计。也是运行速度最快的存储区域
在jvm规范中，每个线程都有它自己的程序计数器，是线程私有的，生命周期与线程的生命周期保持一致
任何时间一个线程都只有一个方法在执行，也就是所谓的当前方法。程序计数器会存储当前线程正在执行的java方法的JVM指令地址；或者，如果实在执行native方法，则是未指定值（undefined）。
它是程序控制流的指示器，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成
字节码解释器工作时就是通过改变这个计数器的值来选取吓一跳需要执行的字节码指令
它是唯一一个在java虚拟机规范中没有规定任何OOM情况的区域

1.2 代码示例

利用javap -v xxx.class反编译字节码文件，查看指令等信息

1.3 面试常问

1.使用PC寄存器存储字节码指令地址有什么用呢？/ 为什么使用PC寄存器记录当前线程的执行地址呢？因为CPU需要不停的切换各个线程，这时候切换回来以后，就得知道接着从哪开始继续执行
JVM的字节码解释器就需要通过改变PC寄存器的值来明确下一条应该执行什么样的字节码指令
2.PC寄存器为什么会设定为线程私有
我们都知道所谓的多线程在一个特定的时间段内指回执行其中某一个线程的方法，CPU会不停滴做任务切换，这样必然会导致经常中断或恢复，如何保证分毫无差呢？**为了能够准确地记录各个线程正在执行的当前字节码指令地址，最好的办法自然是为每一个线程都分配一个PC寄存器,**这样一来各个线程之间便可以进行独立计算，从而不会出现相互干扰的情况。
由于CPU时间片轮限制，众多线程在并发执行过程中，任何一个确定的时刻，一个处理器或者多核处理器中的一个内核，只会执行某个线程中的一条指令。
这样必然导致经常中断或恢复，如何保证分毫无差呢？每个线程在创建后，都会产生自己的程序计数器和栈帧，程序计数器在各个线程之间互不影响。

CPU时间片

CPU时间片即CPU分配各各个程序的时间，每个线程被分配一个时间段。称作它的时间片。
在宏观上：我们可以同时打开多个应用程序，每个程序并行不悖，同时运行。但在微观上：由于只有一个CPU，一次只能处理程序要求的一部分，如何处理公平，一种方法就是引入时间片，每个程序轮流执行。

2.栈帧内部结构

局部变量表

局部变量表也被称之为局部变量数组或本地变量表
定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量这些数据类型包括各类基本数据类型、对象引用（reference），以及returnAddressleixing
由于局部变量表是建立在线程的栈上，是线程私有的数据，因此不存在数据安全问题
局部变量表所需的容量大小是在编译期确定下来的,并保存在方法的Code属性的maximum local variables数据项中。在方法运行期间是不会改变局部变量表的大小的
**方法嵌套调用的次数由栈的大小决定。一般来说，栈越大，方法嵌套调用次数越多。**对一个函数而言，他的参数和局部变量越多，使得局部变量表膨胀，它的栈帧就越大，以满足方法调用所需传递的信息增大的需求。进而函数调用就会占用更多的栈空间，导致其嵌套调用次数就会减少。
**局部变量表中的变量只在当前方法调用中有效。**在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。当方法调用结束后，随着方法栈帧的销毁，局部变量表也会随之销毁。

局部变量表中的变量也是重要的垃圾回收根节点，只要被局部变量表中直接或间接引用的对象都不会被回收

操作数栈

操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈（push）或出栈（pop）

操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。
操作数栈就是jvm执行引擎的一个工作区，当一个方法开始执行的时候，一个新的栈帧也会随之被创建出来，这个方法的操作数栈是空的
每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译器就定义好了，保存在方法的code属性中，为max_stack的值。
栈中的任何一个元素都是可以任意的java数据类型
- 32bit的类型占用一个栈单位深度
- 64bit的类型占用两个栈深度单位
操作数栈并非采用访问索引的方式来进行数据访问的，而是只能通过标砖的入栈push和出栈pop操作来完成一次数据访问
**如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中，**并更新PC寄存器中下一条需要执行的字节码指令。
操作数栈中的元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译期间进行验证，同时在类加载过程中的类验证阶段的数据流分析阶段要再次验证。

动态链接

每一个栈帧内部都包含一个指向运行时常量池或该栈帧所属方法的引用。包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接。比如invokedynamic指令
在Java源文件被编译成字节码文件中时，所有的变量和方法引用都作为符号引用（symbolic Refenrence）保存在class文件的常量池里。比如：描述一个方法调用了另外的其他方法时，就是通过常量池中指向方法的符号引用来表示的，那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用。

方法返回地址

存放调用该方法的PC寄存器的值。
一个方法的结束，有两种方式：
- 正常执行完成
- 出现未处理的异常，非正常退出
无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置。方法正常退出时，**调用者的pc计数器的值作为返回地址，即调用该方法的指令的下一条指令的地址。**而通过异常退出时，返回地址是要通过异常表来确定，栈帧中一般不会保存这部分信息。
本质上，方法的退出就是当前栈帧出栈的过程。此时，需要恢复上层方法的局部变量表、操作数栈、将返回值也如调用者栈帧的操作数栈、设置PC寄存器值等，让调用者方法继续执行下去。
正常完成出口和异常完成出口的区别在于：通过异常完成出口退出的不会给他的上层调用者产生任何的返回值。

一些附加信息

栈帧中还允许携带与java虚拟机实现相关的一些附加信息。例如，对程序调试提供支持的信息。（很多资料都忽略了附加信息）

3. 虚拟机栈的5道面试题

1.举例栈溢出的情况？（StackOverflowError）

递归调用等，通过-Xss设置栈的大小；

2.调整栈的大小，就能保证不出现溢出么？

不能如递归无限次数肯定会溢出，调整栈大小只能保证溢出的时间晚一些

3.分配的栈内存越大越好么？

不是会挤占其他线程的空间

4.垃圾回收是否会涉及到虚拟机栈？

不会

内存区块	Error	GC
程序计数器	❌	❌
本地方法栈	✅	❌
jvm虚拟机栈	✅	❌
堆	✅	✅
方法区	✅	✅

5.方法中定义的局部变量是否线程安全？

要具体情况具体分析

/**
 * 面试题：
 * 方法中定义的局部变量是否线程安全？具体情况具体分析
 *
 * 何为线程安全？
 *     如果只有一个线程可以操作此数据，则毙是线程安全的。
 *     如果有多个线程操作此数据，则此数据是共享数据。如果不考虑同步机制的话，会存在线程安全问题
 *
 * StringBuffer是线程安全的，StringBuilder不是
 */
public class StringBuilderTest {

    //s1的声明方式是线程安全的
    public static void method1(){
        StringBuilder s1 = new StringBuilder();
        s1.append("a");
        s1.append("b");
    }

    //stringBuilder的操作过程：是不安全的，因为method2可以被多个线程调用
    public static void method2(StringBuilder stringBuilder){
        stringBuilder.append("a");
        stringBuilder.append("b");
    }

    //s1的操作：是线程不安全的 有返回值，可能被其他线程共享
    public static StringBuilder method3(){
        StringBuilder s1 = new StringBuilder();
        s1.append("a");
        s1.append("b");
        return s1;
    }

    //s1的操作：是线程安全的 ，StringBuilder的toString方法是创建了一个新的String，s1在内部消亡了
    public static String method4(){
        StringBuilder s1 = new StringBuilder();
        s1.append("a");
        s1.append("b");
        return s1.toString();
    }

    public static void main(String[] args) {
        StringBuilder s = new StringBuilder();
        new Thread(()->{
            s.append("a");
            s.append("b");
        }).start();

        method2(s);

    }

}

4.本地方法栈

Java虚拟机栈用于管理Java方法的调用，而本地方法栈用于管理本地方法的调用
本地方法栈，也是线程私有的。
允许被实现成固定或者是可动态拓展的内存大小。（在内存溢出方面是相同的）
- 如果线程请求分配的栈容量超过本地方法栈允许的最大容量，Java虚拟机将会抛出一个StackOverFlowError异常。
- 如果本地方法栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的本地方法栈，那么java虚拟机将会抛出一个OutOfMemoryError异常。
本地方法是使用C语言实现的
它的具体做法是Native Method Stack中登记native方法，在Execution Engine执行时加载本地方法库。
当某个线程调用一个本地方法时，它就进入了一个全新的并且不再受虚拟机限制的世界。它和虚拟机拥有同样的权限
- 本地方法可以通过本地方法接口来 访问虚拟机内部的运行时数据区
- 它甚至可以直接使用本地处理器中的寄存器
- 直接从本地内存的堆中分配任意数量的内存
并不是所有的JVM都支持本地方法。因为Java虚拟机规范并没有明确要求本地方法栈的使用语言、具体实现方式、数据结构等。如果JVM产品不打算支持native方法，也可以无需实现本地方法栈。
在hotSpot JVM中，直接将本地方法栈和虚拟机栈合二为一。

String

new String(“ab”)会创建几个对象,new String(“a”)+new String(“b”)呢

new String(“ab”)在字符串常量池中会创建对象"ab";

new String(“a”)+new String(“b”)通过StringBuilder的toString中的返回new String(“ab”)并没有在字符串常量池中创建"ab"

public class StringNewTest {
    public static void main(String[] args) {
//        String str = new String("ab");

        String str = new String("a") + new String("b");
    }
}

new String(“ab”)会创建几个对象？看字节码，就知道是两个。
- 一个对象是：new关键字在堆空间创建的
- 另一个对象是：字符串常量池中的对象"ab"。字节码指令：ldc
new String(“a”) + new String(“b”)呢？
- 对象1：new StringBuilder()
- 对象2： new String(“a”)
- 对象3：常量池中的"a"
- 对象4： new String(“b”)
- 对象5：常量池中的"b"
深入剖析： StringBuilder的toString():
- 对象6 ：new String(“ab”)
- 强调一下，toString()的调用，在字符串常量池中，没有生成"ab"
```
String str = "ab";

String str = "a" + "b";
```

在这里插入图片描述

这两种都只有一个字符串常量词对象"ab";

关于String.intern()的面试题

/**
 * 如何保证变量s指向的是字符串常量池中的数据呢？
 * 有两种方式：
 * 方式一： String s = "shkstart";//字面量定义的方式
 * 方式二： 调用intern()
 *         String s = new String("shkstart").intern();
 *         String s = new StringBuilder("shkstart").toString().intern();
 *
 */
public class StringIntern {
    public static void main(String[] args) {
        String s = new String("1");
        String s1 = s.intern();//调用此方法之前，字符串常量池中已经存在了"1"
        String s2 = "1";
        //s  指向堆空间"1"的内存地址
        //s1 指向字符串常量池中"1"的内存地址
        //s2 指向字符串常量池已存在的"1"的内存地址  所以 s1==s2
        System.out.println(s == s2);//jdk6：false   jdk7/8：false
        System.out.println(s1 == s2);//jdk6: true   jdk7/8：true
        System.out.println(System.identityHashCode(s));//491044090
        System.out.println(System.identityHashCode(s1));//644117698
        System.out.println(System.identityHashCode(s2));//644117698

        //s3变量记录的地址为：new String("11")
        String s3 = new String("1") + new String("1");
        //执行完上一行代码以后，字符串常量池中，是否存在"11"呢？答案：不存在！！

        //在字符串常量池中生成"11"。如何理解：jdk6:创建了一个新的对象"11",也就有新的地址。
        //         jdk7:此时常量中并没有创建"11",而是创建一个指向堆空间中new String("11")的地址
        s3.intern();
        //s4变量记录的地址：使用的是上一行代码代码执行时，在常量池中生成的"11"的地址
        String s4 = "11";
        System.out.println(s3 == s4);//jdk6：false  jdk7/8：true
    }

}

总结String的intern（）的使用

jdk 1.6 字符串常量池是在方法区的永久代中的 jdk1.7之后跟对象一样存放在堆中了所以为了节省空间直接将对象的引用地址保存在字符串常量池中就可以了

jdk1.6中，将这个字符串对象尝试放入串池。
- ➢如果字符串常量池中有，则并不会放入。返回已有的串池中的对象的地址
- ➢如果没有，会把此对象复制一份，放入串池，并返回串池中的对象地址
Jdk1.7起，将这个字符串对象尝试放入串池。
- ➢如果字符串常量池中有，则并不会放入。返回已有的串池中的对象的地址
- ➢如果没有，则会把对象的引用地址复制一份，放入串池，并返回串池中的引用地址

jdk6

jdk8

在这里插入图片描述

11",也就有新的地址。
// jdk7:此时常量中并没有创建"11",而是创建一个指向堆空间中new String(“11”)的地址
s3.intern();
//s4变量记录的地址：使用的是上一行代码代码执行时，在常量池中生成的"11"的地址
String s4 = “11”;
System.out.println(s3 == s4);//jdk6：false jdk7/8：true
}

}


### 总结String的intern（）的使用

jdk 1.6 字符串常量池是在方法区的永久代中的  jdk1.7之后跟对象一样存放在堆中了 所以为了节省空间直接将对象的引用地址保存在字符串常量池中就可以了 

- jdk1.6中，将这个字符串对象尝试放入串池。
  - ➢如果字符串常量池中有，则并不会放入。返回已有的串池中的对象的地址
  - ➢如果没有，会把此对象复制一份，放入串池，并返回串池中的对象地址
- Jdk1.7起，将这个字符串对象尝试放入串池。
  - ➢如果字符串常量池中有，则并不会放入。返回已有的串池中的对象的地址
  - **➢如果没有，则会把对象的引用地址复制一份，放入串池，并返回串池中的引用地址**

**jdk6**

[外链图片转存中...(img-F1HGeS18-1598497193597)]

**jdk8**

[外链图片转存中...(img-kgBIQXUb-1598497193598)]

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210311161305817.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1Y3lsYWxhMDA3,size_16,color_FFFFFF,t_70)