JVM基础知识

JVM学习

jvm

前提

课程章节

1. 内存与垃圾回收
1. 字节码与类的加载
1. 性能监控与调优篇

jdk 版本

6,7,8,11-LTS,(现在都是 8,否则就是 11)

‍

JVM 与 java 体系结构

前言

之前遇到的问题
- 运行着的线上系统突然卡死,系统无法访问,甚至直接 O0M!
- 解决 JVM GC 问题,但却无从下手。
- 新项目上线,对各种 JVM 参数设置一脸茫然,直接默认吧,然后就 GG 了,每次面试之前都要重新背一遍 JVM 的一些原理概念性的东西,然而面试官却经常问你在实际项目中如何调优 JVM 参数,如何解决 GC.OOM 等问题,一脸懵逼。
Java 项目体系结构
cpu 运行体系结构
java 和 c++ 的不同
- java 内存自动分配,c++ 手动分配
- java 垃圾自动回收,c++ 手动回收

java 和 JVM 简介

java 生态:指的是编译后的文件支持跨平台,而不是文件支持跨平台
- 作为一个平台, Java 虚拟机扮演着举足轻重的作用。Groovy, Scala, JRuby、 Kotlin 等都是 Java 平台的一部分
- 作为开源的文化.java 很多第三方框架和软件都是开源的,如:tomcat,spring,mybatis,就连 jdk 和 JVM 都有对应的开源版本,oracle 公司发布了商业版本付费的 sunjdk,也有开源的 openjdk,还有开源的虚拟机 harmony(由 intel 和 ibm 开发)
java 的发展
- 1. 1996 年 sun 公司开发出来 java1.0,并且使用了 classic 虚拟机,1.3 版本后使用 hotspot 虚拟机
- 1. 1.5 发布了全新版本的 java,并且版本也改为了 java 5.0,不再是以前的 java 1.x 了
- 1. java 开源了 openjdk,openjdk 使用的虚拟机就是 hotspot
- 1. 2010 年 oracle 收购了 sun,获得 java 商标和 hotspot 虚拟机和 bea 公司的 jrockit 虚拟机,并对二者进行整合,称为 hotrockit,但是现在整合后仍然叫做 hotspot
- 1. 2011 年 jdk7 发布,引入了 gc 垃圾回收器,替代了之前的 cms
- 1. 2018 年年发布了 jdk11 LTS 版本,并发布了最新的 zgc 垃圾回收器
- 1. 每一个 java 版本都会发布两个版本的 jdk
JVM:只需要字节码文件,不需要关心字节码文件是由哪个编程语言的编译而来的,所以说 JVM 并不是跟 java 做了绑定的
- 字节码
  - 我们平时说的 java 字节码,指的是用 java 语言编译成的字节码。准确的说任何能在 JVM 平台上执行的字节码格式都是一样的。所以应该统称为:JVM 字节码。
- 多语言混合编程
  - 试想一下,在一个项目之中,并行处理用 Clojure 语言编写,展示层使用 JRuby/Rails,中间层则是 Java,每个应用层都将使用不同的编程语言来完成,而且,接口对每一层的开发者都是透明的,各种语言之间的交互不存在任何困难,就像使用自己语言的原生 API 一样方便,因为它们最终都运行在一个虚拟机之上。

虚拟机和 java 虚拟机

所谓虚拟机(Virtual Machine),就是一台虚拟的计算机。它是一款软件,用来执行一系列虚拟计算机指令。大体上,虚拟机可以分为和。无论是系统虚拟机还是程序虚拟机,在上面运行的软件都被限制于虚拟机提供的资源中。
分类
- 系统虚拟机
  - 大名鼎鼎的 Virtual Box, vMware 就属于系统虚拟机,它们完全是对物理计算机的仿真,提供了一个可运行完整操作系统的软件平台。
- 程序虚拟机
  - 程序虚拟机的典型代表就是 Java 虚拟机,它专门为执行单个计算机程序而设计,在 Java 虚拟机中执行的指令我们称为 Java 字节码指令。(后面学习的 bipush 等)
java 虚拟机
- Java 虚拟机就是二进制字节码的(.class 文件)运行环境,负责装载字节码到其内部,解释/编译为对应平台上的机器指令执行。每一条 Java 指令, Java 虚拟机规范中都有详细定义,如怎么取操作数,怎么处理操作数,处理结果放在哪里。
特点
- 一次编译,到处运行
  - 跨平台指的是编译后的文件支持跨平台,而不是文件支持跨平台
- 自动内存管理,降低内存泄露,溢出的风险
- 自动垃圾回收功能
体系结构
JVM 所处在 java 体系的位置

JVM 整体结构

结构简图(下一章节有更详细的图)
JVM 是可运行 Java 代码的假想计算机，包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收，堆和一个存储方法域。 JVM 是运行在操作系统之上的，它与硬件没有直接的交互.

java 代码的执行过程

简图
详细图

JVM 的架构模型

‍
- 基于栈的指令集架构(JVM 采用的就是这种方式,因为 jvm 的操作数是保存在操作数栈的),cpu 执行的指令直接操作栈中的操作数
- 基于寄存器的指令集架构,cpu 执行的指令直接操作寄存器中的操作数字
- 总结:这里说的 基于栈/寄存器的指令集 是看操作数是存放在 栈 中,还是 寄存器 中
基于栈的指令集架构
- 设计和实现更简单(只有出栈入栈的操作),适用于资源受限的系统;(cpu 硬件缺乏较多的寄存器)
- 避开了寄存器的分配难题:使用零地址指令方式分配。(只需要操作栈顶的指令)
- 指令流中的指令大部分是零地址指令,其执行过程依赖于操作栈。指令集更小编译器容易实现,但是指令个数多(指令集就是所有的指令的集合,指令集小的意思是单个指令小,是因为零地址指令)
- 不需要硬件支持,可移植性更好,更好实现跨平台(不需要特定的 cpu 提供的特殊的寄存器)
基于寄存器的指令集架构
- 典型的应用是 x86 的二进制指令集:比如传统的 PC 以及 Android 的 Davlik 虚拟机。
- 指令集架构则完全依赖硬件,可移植性差性能优秀和执行更高效;(依赖寄存器,cpu 缓存,不需要反复弹栈入栈,执行高效)
- 花费更少的指令去完成一项操作。(因为有多地址指令,因为指令是有指令周期的概念,也就是 cpu 频率)
- 在大部分情况下,基于寄存器架构的指令集往往都以一地址指令、二地址指令和三地址指令为主,而基于栈式架构的指令集却是以零地址指令为主
总结
- 基于栈的指令集架构
  - 跨平台
    - 虽然是基于内存实现的栈,但是最终还是要加载到 cpu 的缓存,然后是 cpu 的寄存器中,不也是用到了 cpu 的寄存器嘛?
      - 这样怎么跨平台?难道是所有 cpu 都有的通用寄存器?---> 就用 cpu 的一号寄存器完成指令
      - 为什么会说 java 的运行速度无限接近 c/c++?常用的指令不再是解释执行,而是把热点代码编译成机器指令,直接执行,避免了解释运行速度慢的问题
  - 指令集小
  - 指令数量多
  - 执行效率低
- 基于寄存器的指令集架构
  - 不跨平台
  - 指令集大
  - 指令数量少
  - 执行效率高

JVM 的生命周期

开始
- Java 虚拟机的启动是通过引导类加载器(bootstrap class loader) 创建一个初始类(initial class)来完成的,这个类是由虚拟机的具体实现指定的。
执行
- 一个运行中的 Java 虚拟机有着一个清晰的任务:执行 Java 程序。
- 程序开始执行时他才运行,程序结束时他就停止。
- 执行一个所谓的 Java 程序的时候,真真正正在执行的是一个叫做 Java 虚拟机的进程。(程序在运行的时候可以通过 jps 命令来查看虚拟机的进程)
- 当一个程序从开始运行，这时虚拟机就开始实例化了，多个程序启动就会存在多个虚拟机实例。程序退出或者关闭，则虚拟机实例消亡，多个虚拟机实例之间数据不能共享。
结束
- 程序正常执行结束
- 程序在执行过程中遇到了异常或错误而异常终止
- 由于操作系统出现错误而导致 Java 虚拟机进程终止
- 某线程调用 Runtime 类或 System 类的 exit 方法,或 Runtime 类的 halt 方法,并且 Java 安全管理器也允许这次 exit 或 halt 操作。(Runtime 类本质上就是对应 JVM 运行图的 ,他是一个饿汉式的单例)

JVM 的发展历程

sun classic vm
- 早在 1996 年 Javal.0 版本的时候, sun 公司发布了一款名为 Sun classicVM 的 Java 虚拟机,它同时也是世界上第一款商用 Java 虚拟机, JDK1 .4 时完全被淘汰。
- 这款虚拟机内部只提供解释器。,如果使用 JIT 编译器,就需要进行外挂。但是一旦使用了 JIT（Just-In-Time Compilation, JIT）编器, JIT 就会接管虚拟机的执行系统。解释器就不再工作。解释器和编译器不能配合工作。
sun exact vm
- 为了解决上一个虚拟机问题, jdk1.2 时, sun 提供了此虚拟机。Exact Memory Management:准确式内存管理,该虚拟机可以知道内存中某个位置的数据具体是什么类型。
- 具备现代高性能虚拟机的维形
  - 热点探测
  - 编译器与解释器混合工作模式
- 只在 Solaris 平台(sun 公司自己服务器)短暂使用,其他平台上还是 classic vm,英堆气短,终被 Hotspot 虚拟机替换
sun hotspot vm
- 不管是现在仍在广泛使用的 JDK6,还是使用比例较多的 JDK8 中,默认的虚拟机都是 HotSpot,广泛用于移动,服务器场景
- sun/oracle JDK 和 openJDK 的默认虚拟机
- hotspot 名称中的 HotSpot 指的就是它的热点代码探测技术。
- 通过计数器找到最具编译价值代码,触发即时编译（Just-In-Time Compilation, JIT）或栈上替换（On-Stack Replacement, OSR）
  - 栈上替换:当计数器达到阈值时，JVM 可以在循环执行中途将字节码替换为机器码。(运行时替换)
- 通过编译器与解释器协同工作,在最优化的程序响应时间与最佳执行性能中取得平衡
BEA jrockit
- 专注于服务器端应用,主要针对启动延迟不敏感的客户,所以基本没有解释器,全部使用 jit 技术
- JRockit JVM 是世界上最快的 JVM.
- JRockit 面问延迟敏感型应用的解决方案 JRockit Real Time 提供以毫秒或微秒级的 JVM 响应时间,适合财务、军事指挥、电信网络的需要
- MissionControl 服务套件,它是一组以极低的开销来监控、管理和分析生产环境中的应用程序的工具。
ibm j9
- 市场定位与 HotSpot 接近,服务器端、桌面应用、嵌入式等多用途 VM
- 广泛用于 IBM 的各种 Java 产品。
- 也号称是世界上最快的 Java 虚拟机,但是是运行在 ibm 自己的服务器产品上
非主流 JVM
- kvm 虚拟机:面向比移动设备更低端的设备:老人手机,单片机...
- dalvik vm
  - 谷歌开发的,应用于 Android 系统,并在 Android2.2 中提供了 JIT,发展迅猛。
  - Dalvik VM 只能称作虚拟机,而不能称作"Java 虚拟机” ,它没有遵循 Java 虚拟机规范
  - 基于寄存器架构,不是 JVM 的栈架构。
  - 执行的是编译以后的 dex (Dalvik Executable)文件。执行效率比较高。
  - 它执行的 dex (Dalvik Executable)文件可以通过 Class 文件转化而来,使用 Java 语法编写应用程序,可以直接使用大部分的 Java API 等。
  - Android 5.0 使用支持提前编译(Ahead of Time Compilation, AOT)的 ART VM 替换 Dalvik VM.
  - 谷歌当年想用 c 来开发,但是由于 c 的开发效率低,而且 sun 公司主动请谷歌使用 java,巩固了 java 的地位

类加载子系统

这个章节的类加载器讲解的并不详细,我们只需要知道类加载器起到了是什么作用,后续再进行研究

类加载器和类的加载过程

类加载器子系统
- 特点
  - 类加载器子系统负责从文件系统或者网络中加载 class 文件, class 文件在文件开头有特定的文件标识(CAFFBABE)。
  - ClassLoader class 文件的加载,至于它是否可以运行,则由 ExecutionEngine 决定。
  - 加载的类信息存放于一块称为方法区的内存空间。除了类的信息外,方法区中还会存放运行时常量池信息,可能还包括字符串字面量,变量名称和数字常量(这部分常量信息是 Class 文件中常量池部分的内存映射),运行时常量池是在类加载时从 Class 文件的常量池部分加载到方法区的。
    - 常量池:用于存放编译期生成的各种字面量和符号引用，这部分内容将在类加载后存放到方法区的运行时常量池中。 Java 虚拟机对 Class 文件的每一部分（自然也包括常量池）的格式都有严格的规定，每一个字节用于存储哪种数据都必须符合规范上的要求，这样才会被虚拟机认可、装载和执行
- 示例
  1. class file 存在于本地硬盘上,可以理解为设计师画在纸上的模板,而最终这个模板在执行的时候是要加载到 JVM 当中来根据这个文件实例化出 n 个一模一样的实例。
  2. class file 加载到 JVM 中,被称为 DNA 元数据模板,放在方法区。
  3. 在 .class 文件-> JVM-> 最终成为元数据模板,此过程就要一个运输工具(类装载器 Class Loader) ,扮演一个快递员的角色
类的加载过程
- 用户自定义类的加载过程流程图
- 类的加载过程分为三个阶段:加载->链接->初始化
  1. 加载阶段(loading)
    1. 通过一个类的全限定类名获取定义此类的二进制字节流
      - 常见
        
        注意这里不一定非得要从一个 Class 文件获取，这里既可以从 ZIP 包中读取（比如从 jar 包和 war 包中读取），也可以在运行时计算生成（动态代理），也可以由其它文件生成（比如将 JSP 文件转换成对应的 Class 类）。
      - 更多方法
        
        从本地系统中直接加载
        
        通过网络获取,典型场景: Web Applet
        
        从 zip 压缩包中读取,成为日后 jar, war 格式的基础
        
        运行时计算生成,使用最多的是:动态代理技术
        
        由其他文件生成,典型场景: JSP 应用
        
        从专有数据库中提取.class 文件,比较少见
        
        从加密文件中获取,典型的防 Class 文件被反编译的保护措施
    2. 将这个字节流所代表的静态文件结构转化为方法区的运行时数据结构,方法区在 jdk7 及其以前叫做永久代,jdk7 之后叫做元空间
    3. 在内存中生成一个代表这个类的 java.1ang.Class 对象,作为方法区这个类的各种数据的访问入口
  2. 链接阶段(linking)
    - 验证
      - 目的在于确保 Class 文件的字节流中包含信息符合当前虚拟机要求,保证被加载类的正确性,不会危害虚拟机自身安全。(使用 PXBinaryViewer.exe 和 JClassLib.exe 查看),如果不合法,会弹出验证错误
      - 主要包括四种验证
        
        文件格式验证,
        
        元数据验证,
        
        字节码验证
        
        符号引用验证。
    - 准备
      - 为类变量(类中 static 修饰的静态成员变量)分配内存并且设置该类变量类型对应的的默认初始值,(int 即为零值)
        
        准备阶段,即使我们赋值是 1,但是在准备阶段,其值也是 0,直到在初始化阶段,才会被真正赋值为 1.
        
        int 默认为 0
        
        float 默认为 0.0
        
        char 默认为 \u0000
        
        boolean 默认为 false
        
        引用类型就是 null
        
        这里不包含 final 修饰的 static, 因为 final 在编译(前端编译器)的时候就会分配值了,即为 class 文件中已经硬编码了,因此 final 修饰的 static 变量会在进行加载-> 验证-> 准备-> 解析-> 初始化的过程,在准备阶段就会显式初始化;
        
        通过反编译方法可以看出只有类变量 a 被赋值,这是因为类变量 a 没有使用 final 修饰,需要经过并在初始化阶段被赋值,而使用 final 修饰的变量 b 已经在准备阶段已经赋值了
        
        通过反编译可以看出只有类变量 b 没有被赋值,这是因为编译后的 class 文件中,已经显示指明了变量 b 的值,在准备阶段已经赋值了
      - 这里不会为实例变量分配初始化,类变量会分配在方法区中(jdk7 及其以前叫永久代,jdk8 后叫元空间),而实例变量是会随着对象一起分配到 Java 堆中。
        
        private static int a = 1;
        
        类变量 a 位于方法区中(jdk7 及其以前位于永久代中,jdk8 位于元空间中)
        
        1 位于方法区的运行时常量池中
        
        private static Object o = new Object();
        
        类变量 o 位于方法区中(jdk7 及其以前位于永久代中,jdk8 位于元空间中)
        
        new Object() 位于堆中
    - 解析
      - 将常量池内的符号引用转换为直接引用的过程。
        
        符号引用是指在常量池中以字符串形式表示的对类、接口、字段或方法的引用。这些引用在编译时生成，并在运行时解析。
        
        将符号引用解析为类,接口,字段或方法的直接引用。虚拟机会根据符号引用找到对应的类或接口的定义，并加载到内存中。
        
        符号引用
        
        就是.class 文件中的等字符串常量
        
        符号引用与虚拟机实现的布局无关，引用的目标并不一定要已经加载到内存中。各种虚拟机实现的内存布局可以各不相同，但是它们能接受的符号引用必须是一致的，因为符号引用的字面量形式明确定义在 Java 虚拟机规范的 Class 文件格式中。
        
        直接引用
        
        直接引用可以是指向目标的指针，相对偏移量或是一个能间接定位到目标的句柄。如果有了直接引用，那引用的目标必定已经在内存中存在。
      - 事实上,解析操作往往会伴随着 JVM 在执行完初始化之后再执行。
      - 符号引用就是一组符号来描述所引用的目标。符号引用的字面量形式明确定义在《java 虚拟机规范》的 Class 文件格式中。直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。
      - 解析动作主要针对类或接口、字段、类方法、接口方法、方法类型等。对应常量池中的 CONSTANT Class info, CONSTANT Fieldref info, CONSTANT Methodref info 等
  3. 初始化阶段(initialization)
    - 初始化阶段就是执行"类构造方法<clinit> ()"的过程。这里类构造方法并不是执行类的构造函数,而是一个由 javac 前端编译器自动生成的方法,名称就是 <clinit>,此方法不需定义,是 javac 编译器自动收集类中的所有 类变量(static 修饰的类的成员变量) 的赋值动作和 静态代码块 中的语句合并而来。
      - 注意不是类的成员变量
      - 静态代码块和静态成员变量就是在这个初始化阶段开始执行的
      - 如果没有静态变量(类变量)或者静态代码块,就不会有 类构造方法方法 clinit()
        
        代码
        
        class
        
        需要指出的是静态变量在 jdk6 的时候位于永久代,jdk7 以后位于堆中
      - 案例
        
        代码
        
        class 分析
        
        iconst_:把 int 类型的常数 i 放入到栈帧操作数栈中(类变量赋值使用的是 <clinit>方法)
        
        putstatic #x:从操作数栈中取出栈顶数据为符号索引为 #x 的类变量赋值,如果类变量为 boolean,byte,char,short,int,那么操作数栈顶的数据必须是 int,如果类变量声明的是 float,double,long,栈顶数据必须是 float,double,long.如果类变量声明的是引用类型,那么栈顶数据应该是一个对象的地址
    - 类构造方法(不是类的构造方法)中指令按语句在源文件中出现的顺序执行。
      - 案例
        
        代码分析:这里的 num 看似在下面声明,并且在上面的 static 静态代码块进行赋值,但是本质上已经在链接的准备阶段已经为 num 在分配了内存,并且设置为 int 类型的默认值 0.
        
        class 分析
    - <clinit> () 不同于类的构造方法。(关联:类的构造方法就是 <init>()). 若该类具有父类, JVM 会保证子类的 <clinit> () 执行前,父类的 <clinit>() 已经执行完毕。
      - 案例
        
        代码
        
        (子类)class 分析:会先运行父类的方法,再运行子类的方法,TODO: 虽然结论是父类的静态变量和静态方法都不会被子类继承,但是为什么子类还是可以 Son.A,结论位于 https://www.cnblogs.com/coder-who/p/8419184.html
        
        由下图可以看出,子类确实可以做到访问父类的类变量
        
        (子类)class 分析:如果用到了父类的类变量,则会会先运行父类的方法,再运行子类的方法,否则只运行子类的方法
    - 虚拟机必须保证一个类的 <clinit> () 方法在多线程下被同步加锁。
      - 这里由于 <clinit>方法 只会在类加载的过程中执行一次,需要考虑到当有多个线程同时想要加载该类的时候,不应该出现重复加载的过程,所以说虚拟机必须保证一个类的 <clinit>方法 必须在多线程下同步完成
      - 这里的意思并不是程序在运行的时候,而是在加载的时候,当多个线程同时执行 <clinit>方法,因为 <clinit>方法 只会在加载的时候执行一次,

类加载器的分类

JVM 规范的类加载器的分类
- 引导类加载器(BootstrapClassLoader):使用 c/c++ 实现的
- 自定义类加载器(User-Defined ClassLoader):使用 java 实现的
  - 从概念上来讲, 自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器,但是 Java 虚拟机规范却没有这么定义,而是将所有派生于抽象类 ClassLoader 的类加载器都划分为自定义类加载器。
  - 拿 ExtClassLoader 类加载器进行举例

类加载器的代码分析

JVM 为我们提供的最底层的类加载器就是系统类加载器 AppClassloader

    public static void main(String[] args) {
        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader() ;
        System.out.println(systemClassLoader);//sun.misc. Launcher $AppClassloader@18b4aac2
        //获取其上层：扩展类加载器
        ClassLoader extClassLoader = systemClassLoader.getParent() ;
        System.out.println(extClassLoader) ;//sun.misc. Launcher$ExtClassLoader@1540e19d
        //获取其上层：
        ClassLoader bootstrapClassLoader = extClassLoader.getParent();
        System.out.println(bootstrapClassLoader);//null,后面会解释为什么是null
		//java 的核心类库都是使用引导类加载器进行加载的,引导类加载器是由 c/c++ 编写的,所以我们获取不到

对于用户自定义的类,默认使用系统类加载器 AppClassloader 加载
java 的核心类库都是使用引导类加载器进行加载的,由于 String(位于 rt.jar) 也是 java 的核心库,所以 String 也是通过引导类加载器完成加载的.但是引导类加载器我们无法获取其对象,因为他是由 c/c++ 编写的,比较高级(这就解释了上面为什么获取不到引导类加载器)

虚拟机自带的加载器
- 启动类加裁器(引导类加载器, Bootstrap ClassLoader):主要用来加载 JVM 使用的核心包
  - 概念
    - 这个类加载使用 c/c++ 语言实现的,嵌套在 JVM 内部。等于是 JVM 本身的一部分
    - 它用来加载 Java 的核心库(JAVA HOME/jre/lib/rt.jar,resources.jar 或 sun.boot.class.path 路径下的内容) ,用于提供 JVM 自身需要的类(String 位于 rt.jar)
    - 并不继承自 java .lang.ClassLoader,没有父加载器。(因为是使用的 c/c++ 编写的,所以不在 java 的体系中)
    - 加载扩展类加载器 ExtClassLoader 和应用程序类加载器 AppClassloader,并指定为他们的父类加载器。
    - 出于安全考虑, Bootstrap 启动类加载器只加载包名为 java, javax.sun 等开头的类
  - 代码分析
    - 获取启动类加载器加载的 api 路径
    - 程序输出结果
- 扩展类加载器(Exetension ClassLoader):主要用来加载核心包之外的扩展包
  - 概念
    - Java 语言编写,由 sun.misc. Launcher$ExtclassLoader 实现。(Launcher 的内部类)
    - 派生于 ClassLoader 类
    - 父类加载器为启动类加载器(BootStrap ClassLoader)
    - 从 java .ext.dirs 系统属性所指定的目录中加载类库,或从 JDK 的安装目录的 jre/lib/ext 子目录(扩展目录)下加载类库。如果用户创建的 JAR 放在此目录下,也会自动由扩展类加载器加载。
  - 代码分析
    - 获取扩展类加载器加载的 api 路径
    - mac 路径下的拓展类加载器的 api 路径
- 应用程序类加载起(系统类加载器,AppClassLoader)
  - 概念
    - java 语言编写,由 sun.misc.Launcher$AppClassLoader 实现
    - 派生于 ClassLoader 类
    - 父类加载器为扩展类加载器(Exetension ClassLoader)
    - 它负责加载环境变量 Classpath 或系统属性 java. class.path 指定路径下的类库
    - 该类加载是程序中默认的类加载器,一般来说, Java 应用的类都是由它来完成加载,我们自定义的类也是使用这种加载器进行加载的
    - 通过 ClassLoader.getSystemClassLoader ()方法可以获取到该类加载器
~~用户自定义类加载器(了解)~~
- 引入
  - 在 Java 的日常应用程序开发中,类的加载几乎是由上述 3 种类加载器相互配合执行的,在必要时,我们还可以自定义类加载器,来定制类的加载方式。
- 使用自定义类加载器的场景
  1. 隔离加载类 (防止 jar 包冲突)
  2. 修改类加载的方式(不是所有类加载起都需要启动,我们可以自定义使用哪写类加载器)
  3. 扩展加载源(可以指定 jar 包的路径来加载类)
  4. 防止源码泄漏(在加载二进制 class 文件的时候,我们可以先进行加解密,来完成防止源码泄露)
- 自定义类加载器的步骤
  1. 开发人员可以通过继承抽象类 java . lang.ClassLoader 类的方式,实现自己的类加载器,以满足一些特殊的需求
  2. 在 JDK1.2 之前,在自定义类加载器时,总会去继承 classLoader 类并重写 loadclass ()方法,从而实现自定义的类加载类,但是在 JDK1.2 之后已不再建议用户去覆盖 loadClass ()方法,而是建议把自定义的类加载逻辑写在 findClass ()方法中
  3. 在编写自定义类加载器时,如果没有太过于复杂的需求,可以直接继承 URIClassLoader 类,这样就可以避免自己去编写 findClass (1)方法及其获取字节码流的方式,使自定义类加载器编写更加简洁。
~~关于 ClassLoader 抽象类(了解)~~
- 概念
  - ClassLoader 类是一个抽象类,其后所有的类加载起都是其子类==但是不包括启动类加载器==
- 方法(都有默认的实现)
- 获取 ClassLoader 的几种途径
双亲委派****机制
- 引入
  - 如果我们在自己的项目中自定义一个 java.lang.String 类,并且在项目中使用 String 类,那么程序究竟会使用 JVM 提供的 String 还是我们自定义的 String 呢?
  - 实验
    - 自定义一个 java.lang.String 类,并在项目中引入 String 这个类
    - 这就用到了双亲委派机制
- 概念
  - Java 虚拟机对 class 文件采用的是按需加载的方式,也就是说当需要使用该类时才会将它的 class 文件加载到内存生成 class 对象。而且加载某个类的 class 文件时, Java 虚拟机采用的是双亲委派模式,即把加载类的请求交由父类处理,它是一种任务委派模式。
- 双亲委派模式工作原理
  - 如果一个类加载器收到了类加载请求,它并不会自己先去加载,而是把这个请求委托给父类的加载器去执行
  - 如果父类加载器还存在其父类加载器,则进一步向上委托,依次递归,请求最终将到达项层的启动类加载器;
  - 如果父类加载器可以完成类加载任务,就成功返回,倘若父类加载器无法完成此加载任务,子加载器才会尝试自己去加载,这就是双亲委派模式。
- 针对上面使用自定义 java.lang.String 所提出的问题
  - 我们自定义了 java.lang.String,并在加载该自定义类的时候使用了 AppClassLoader 来进行加载
  - 但是由于 双亲委派机制,AppClassLoader 存在父类加载器,所以会一直向上委派加载,直到启动类加载起发现他可以完成类加载任务,所以就会加载 JVM 提供的 java.lang.String,排除我们自定义的类
- 问题升级
  1. 因为我们的盗版 String 都不会被加载,被加载的是 JVM 提供的 java.lang.String,但是该类是没有 main 方法的.所以即使我们在盗版的 String 类上写的 mian 方法,但是在运行该 main 方法时,仍然报未找到 main 方法的错误,这是因为我们使用了双亲委派机制,加载的是真正的 String 类,然而这个类根本没有 main 方法,所以会报这种错误
- 举例 2:如果我们需要加载第三方 jar 包,而这个 jar 包又用到了 java 的核心类,比如 mysql-jdbc.jar ,会怎么加载呢
  1. 对于 mysql-jdbc.jar 这个第三方 jar 包来说,这个 jar 包需要用到 jdk.jdbc 的接口,这个接口由引导类加载器加载,但是这个第三方 jar 包的 jdbc 接口实现类就会通过反向委派系统类加载器进行加载
- 双亲委派机制的优势
  - 可以避免程序的重复加载
  - 保护程序的安全,防止核心的程序被修改
    1. 自定义 java.lang.String,会自动加载 JVM 提供的 String
    2. 自定义 java.lang.raymond,在加载的时候汇报错,因为 java.lang.* 是使用启动类加载器来进行加载的,启动类加载器所加载的路径中并没有这个类,所以会导致报错
  - 沙箱安全机制
    - 所谓的沙箱安全机制就是保护程序的安全,防止核心的程序被修改
其他
1. 如何判加载的两个 Class 对象是否同一个类
  - 类的必须一致,包括包名。
  - 加载这个类的 ClassLoader (指 ClassLoader 实例对象)必须相同。
  - 换句话说,在 JVM 中,即使这两个类对象(class 对象)来源同一个 Class 文件,被同一个虚拟机所加载,但只要加载它们的 ClassLoader 实例对象不同,那么这两个类对象也是不相等的。
2. 对类加载器的引用
  - JVM 必须知道一个类型是由启动(引导)加载器加载的还是由用户类加载器加载的(通过 Class.getClassLoader())。如果一个类型是由用户类加载器加载的,那么 JVM 会将这个类加载器的一个引用作为类型信息的一部分保存在方法区中(因为一个类对应的 class 文件会被加载到方法区中)。当解析一个类型到另一个类型的引用的时候, JVM 需要保证这两个类型的类加载器是相同的。(目前不太理解,动态连接那里在回头看)
3. java 程序对类的使用方式
  - 分类
    - 主动使用
      - 创建类的实例
      - 访问某个类或接口的静态变量,或者对该静态变量赋值
      - 调用类的静态方法
      - 反射(比如:C1ass. forname("com. atgulqu.Test")
      - 初始化一个类的子类
      - Java 虚拟机启动时被标明为启动类的类
      - JDK7 开始提供的动态语言支持:
        
        java.1ang.invoke.Methodhandle 实例的解析结果
        
        REE getstatic、 REF putstatic、 REF invokestatic 句柄对应的类没有初始化,则初始化
    - 被动使用
      - 除掉所有的主动使用的情况,都是被动使用,被动使用不会的导致类在被加载的时候触发初始化阶段
  - 特点
    - 被动使用不会触发类的 初始化 阶段

运行时数据区概述及线程

概述

数据区就是内存的区域
- 内存是非常重要的系统资源,是硬盘和 CPU 的中间仓库及桥梁,承载着操作系统和应用程序的实时运行。JVM 内存布局规定了 Java 在运行过程中内存申请、分配、管理的策略,保证了 JVM 的高效稳定运行。不同的 JVM 对于内存的划分方式和管理机制存在着部分差异。结合 JVM 虚拟机规范,来探讨一下经典的 JVM 内存布局。
数据区的详细结构图
说明
- Java 虚拟机定义了若干种程序运行期间会使用到的运行时数据区,其中有一些会随着虚拟机启动而创建,随着虚拟机退出而销毁。另外一些则是与线程一一对应的,这些与线程对应的数据区域会随着线程开始和结東而创建和销毁。
  - 虚拟机栈(vms) ,本地方法栈(nms) 和程序计数器(pc) 都是线程独有的,一个线程在运行的时候,会调用到本地方法栈和虚拟机栈,一个线程也需要一个程序计数器,来指示下一条指令的地址
  - 方法区和堆是一个 jvm 进程一份
  - 每个线程私有:独立包括程序计数器、栈、本地栈。
  - 线程间共享:堆、堆外内存:包括方法区和 JIT 的代码缓存(因为 JIT 代码缓存就是位于方法区),(其中,方法区域又被成为永久代或元空间)

线程

特点
- 线程是一个程序里的运行单元。JVM 允许一个应用有多个线程并行的执行。
- 在 Hotspot JVM 里,每个线程都与操作系统的本地线程直接映射(一对一映射),当一个 Java 线程准备好执行以后,(准备线程需要的资源,程序计数器,vms,nms 等)此时一个操作系统的本地线程也同时创建。Java 线程执行终止后,本地线程也会回收。
- 操作系统负责所有线程的安排调度到任何一个可用的 CPU 上。一旦本地线程初始化成功,它就会调用 Java 线程中的 run()方法。
- 如果我们的线程正常执行完毕后,就会被终止,同时本地线程被回收,但是如果我们的线程发生了异常,且异常无法被捕获处理,那么 java 的线程就会被终止,同时本地线程将会根据剩下的 java 线程是否全部为守护线程来决定 JVM 主线程的生死,如果全是守护进程,那么 JVM 主线程将会被干掉
~~JVM 系统线程(了解)~~
- 如果你使用 jconsle 或者是任何一个调试工具,都能看到在后台有许多线程在运行。这些后台线程不包括调用 public static void main( string[]) 的 main 线程以及所有这个 main 线程自己创建的线程。
  - 虚拟机线程:这种线程的操作是需要 JVM 达到安全点才会出现。这些操作必须在不同的线程中发生的原因是他们都需要 JVM 达到安全点,这样堆才不会变化。这种线程的执行类型包括”stop-the-world"的垃圾收集,緘程收集,线程挂起以及偏向锁撒销。
  - 周期任务线程:这种线程是时间周期事件的体现(比如中断),他们一般用于周期性操作的调度执行。
  - GC 线程:这种线程对在 JVM 里不同种类的垃圾收集行为提供了支持
  - 编译线程:这种线程在运行时会将字节码编译成到本地代码
  - 信号调度线程:这种线程接收信号并发送给 JVM,在它内部通过调用适当的方法进行处理。

	程序计数器PC	虚拟机栈	虚拟机堆
GC	无	无	有
Stack Overflow Error	无	有(固定栈大小)	无
Out of Memeroy	无	有(栈大小不固定)	有

程序计数器寄存器(PC 寄存器)

介绍
- 图示(栈帧(Stack Frame)主要包含本地变量表(LVA(local variable table)),操作数栈(OS(operator stack)),其他参考此图
- JVM 中的程序计数寄存器( Program Counter Register) 中, Register 的命名源于 CPU 的寄存器,寄存器存储指令相关的现场信息。CPU 只有把数据装入到寄存器才能够运行。
- 这里并非是广义上所指的物理寄存器,或许将其翻译为 PC 计数器(或指令计数器)会更加贴切(也称为程序钩子,指向下一行要运行的指令的位置),并且也不容易引起一些不必要的误会。JVM 中的 PC 寄存器是对物理 PC 寄存器的一种抽象模拟。
问题:既然 JVM 采用的是基于栈方式的指令流,指令自然是通过栈的 push 和 pop 完成执行的,为什么还需要 pc 寄存器来记录下一个要执行的指令的地址呢?
- 省流版:JVM 采用的是基于栈方式的指令流,push和pop的单位是栈帧(方法纬度),而实际执行的时候是指令纬度,所以需要PC来来记录下一个指令的具体地址
- 同时在多线程环境中,cpu 来回切换线程,需要 pc 寄存器为我们记录该线程的下一个指令的位置,方便程序返回现场
作用
- 图示
- PC 寄存器用来存储指向下一条指令的地址, 也即将要执行的指令代码。由执行引擎读取下一条指令。
特点
- 它是一块很小的内存空间,几乎可以忽略不记。也是运行速度最快的存储区域
- 在 JVM 规范中,每个线程都有它自己的程序计数器,是线程私有的,生命周期与线程的生命周期保持一致。(一个线程对应一个 pc 寄存器)
- 任何时间一个线程都只有一个方法在执行,也就是所谓的当前方法。程序计数器会存储当前线程正在执行的 Java 方法的 JVM 指令地址:或者, 如果是在执行 native 方法,则是未指定值( undefined),因为本地方法栈中的方法使用的是 c/c++ 编写的,对于 JVM 的 pc 寄存器肯定是无法显示的
- 它是程序控制流的指示器,分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖个计数器来完成。
- 它是唯一一个在 Java 虚拟机规范中没有规定任何 out of memory error 情况的区域,同时也没有 GC.(后面讲的所有的内存都需要考虑 OOM 和 GC 问题,对于栈来说,就是入栈弹栈,所以没有 GC,但是会存在栈溢出(stack overflow)和 OOM(out of memery),所以需要考虑 OOM,别的内存空间也会需要考虑 OOM 和 GC)
- 字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令。
  - 举例
面试常用的两个问题
- 使用 PC 寄存器存储字节码指令地址有什么用呢? 或者(为什么使用 PC 寄存器记录当前线程的执行地址呢?)
  - 因为 CPU 需要不停的切换各个线程,这时候切换回来以后,就得知道接着从哪开始继续执行。
  - JVM 的字节码解释器就需要通过改变 PC 寄存器的值来明确下一条应该执行什么样的字节码指令
- PC 寄存器为什么会被设定为线程私有?
  - 我们都知道所谓的多线程在一个特定的时间段内只会执行其中某一个线程的方法,CPU 会不停地做任务切换,这样必然导致经常中断或恢复,如何保证分毫无差呢?为了能够准确地记录各个线程正在执行的当前字节码指令地址,最好的办法自然是为每一个线程都分配一个 PC 寄存器,这样一来各个线程之间便可以进行独立计算,从而不会出现相互干扰的情况。

虚拟机栈(java 栈)

虚拟机栈概述
- 由于跨平台性的设计,Java 的指令都是根据栈来设计的。不同平台 CPU 架构不同,所以不能设计为基于寄存器的。
- 优点是跨平台,指令集小,编译器容易实现,缺点是性能下降,实现同样的功能需要更多的指令。
- 堆与栈
  - 栈是运行时的单位,而堆是存储的单位。
  - 即:栈解决程序的运行问题,即程序如何执行,或者说如何处理数据。堆解决的是数据存储的问题,即数据怎么放、放在哪,(当然栈中也存放少量的局部变量等)
- 虚拟机栈是什么
  - Java 虚拟机栈( Java Virtual Machine Stack),早期也叫 Java 栈。
  - 虚拟机栈是线程私有的
- 生命周期
  - 生命周期和线程一致。
- 作用
  - 主管 Java 程序的运行,它保存方法的局部变量(8 种基本数据类型的值,引用类型地址) 、部分结果,并参与方法的调用和返回。
    - 补充:变量的分类
      - 按变量在类中声明的位置
        
        局部变量(类中的方法中声明)
        
        成员变量(类中的方法外声明)
        
        类变量(静态变量)
        
        实例变量
      - 按变量的类型的分类
        
        基本数据类型变量(8 种)
        
        引用数据类型变量(类,数组,接口)
- 栈的优点
  - 栈是一种快速有效的分配存储方式,访问速度仪次于程序计数器。(因为对于栈来说,只有栈顶的元素需要操作,然后就是 push 和 pop)
  - JVM 直接对 Java 栈的操作只有两个:
    - 每个方法执行,伴随着进栈(入栈、压栈)
    - 执行结束后的出栈工作
  - 对于栈来说不存在垃圾回收问题,但是存在栈溢出的情况
- 栈中可能出现的异常
  - Java 虚拟机规范允许 Java 栈的大小是动态的或者是固定不变的。
  - 如果采用固定大小的 Java 虚拟机栈,那每一个线程的 Java 虚拟机栈容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过 Java 虚拟机栈允许的最大容量,Java 虚拟机将会抛出一个 StackoverFlowError 异常。(比如我们在一个方法中,调用该方法本身,就会进入递归,直到发生了 StackOverFlowError)
    - 如何设置栈的大小:通过 -Xss 参数
  - 如果 Java 虚拟机栈可以动态扩展,并且在尝试扩展的时候无法中请到足够的内存,或者在创建新的线程时没有足够的内存去创建对应的虚拟机,那 Java 虚拟机将会抛出ー个 OutofMemoryError 异常。(这个异常跟堆的 OOM 一样)
栈的存储单位:栈帧
- 概念
  - 每个线程都有自己的栈,栈中的数据都是以栈帧( Stack Frame) 的格式存在
  - 在这个线程上正在执行的每个方法都各自对应一个栈帧( Stack Frame),
  - 栈帧是一个内存区块,是一个数据集,维系着方法执行过程中的各种数据信息
- 栈运行的原理
  - JVM 直接对 Java 栈的操作只有两个,就是对栈帧的压栈和出栈,遵循“先进后出”/“后进先出”原则。
  - 在一条活动线程中,一个时间点上,只会有一个活动的栈帧。即只有当前正在执行的方法的栈帧(栈顶栈帧)是有效的,这个栈帧被称为当前栈帧,( Current Frame),与当前栈帧相对应的方法就是当前方法( CurrentMethod),定义这个方法的类就是当前类( Current Class)
  - 执行引擎运行的所有字节码指令只针对当前栈帧进行操作。
  - 如果在该方法中调用了其他方法,对应的新的栈帧会被创建出来,放在栈的顶端.成为新的当前帧。
  - 不同线程中所包含的栈帧是不允许存在相互引用的,即不可能在一个栈帧之中引用另外一个线程的栈帧。
  - 如果当前方法调用了其他方法,方法返回之际,当前栈桢会传回此方法的执行结果给前一个栈帧,接着,虚拟机会 pop 当前栈帧,使得前一个栈帧重新成为当前栈帧。
  - Java 方法有两种返回函数的方式,一种是正常的函数返回,使用 return 指令;另外一种是抛出异常(指的是我们没有捕获的异常,异常就会一层层向上一个栈帧抛出)。不管使用哪种方式,都会导致栈帧被弹出
- 栈帧的内部结构
  - 分为五个部分
    
    局部变量表( Local Variables)
    
    操作数栈( operand stack)(或表达式栈)
    
    动态链接( Dynamic Linking)(实际上是指向运行时常量池的方法引用)
    
    方法返回地址( Return Address)(或方法正常退出或者异常退出的定义)
    
    一些附加信息

局部变量表

局部变量表也被称之为局部变量数组或本地变量表
定义为一个 数字数组,主要用于存储方法参数(形参) 和定义在方法体内的局部变量,这些数据类型包括各类基本数据类型、对象引用( reference),以及方法的返回值(returnaddress)类型。
- 为什么是局部变量表数字数组呢?
  - 因为八种基本类型都是数字或者可以转换成数字(boolean,char,byte),对于引用类型,我们在局部变量表中保存的是引用类型的地址,所以地址也是一个数字类型,对于返回值类型来说,它可以是基本类型或者引用类型,所以也可以用数字表示,所以局部变量表就是一个数字数组
- 疑惑:方法的返回值位于栈帧的局部变量表里吗?
  - 我的理解:猜测不在,由上图可知只有(this,形参,局部变量)
  - ireurn: If no exception is thrown, value is popped from the operand stack of the current frame (§2.6) and pushed onto the operand stack of the frame of the invoker. 翻译:返回值将会从被调用方法的操作数栈弹出,并压入调用者方法的操作数栈中,如果调用者接收返回值,那么就会保存到局部变量表中
由于局部变量表是建立在线程的栈上,是线程的私有数据,因此不存在数据安全问题(这里的安全问题是多线程的时候,操作同一个数据引发的数据安全的问题,但是由于局部变量表是线程私有的,所以不存在这样的安全问题)
局部变量表所需的容量大小是在编译期确定下来的,并保存在方法的 code 属性的 maximum local variables 数据项中。在方法运行期间是不会改变局部变量表的大小的。
- 示例
方法嵌套调用的次数由栈帧的大小决定。一般来说,栈越大,方法嵌套调用次数越多。对一个函数而言,它的参数和局部变量越多,使得局部变量表膨胀, 它的栈帧就越大,进而函数调用就会占用更多的栈空间。这就是为什么递归调用的时候,递归方法里一般不推荐定义局部变量的原因
局部变量表中的变量只在当前方法调用中有效。在方法执行时,虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。当方法调用结東后随着方法栈帧的销毁,局部变量表也会随之销毁。
通过 jClassLib 来简单分析字节码文件(为 JVM 内存做准备)
关于操作数栈 slot 槽 的理解
- 局部变量表,最基本的存储单元是 s1ot(变量槽),(可以理解为数组的一个个元素)
- 参数值的存放总是在局部变量数组的 index0 开始,到数组长度-1 的索引结束。
- 局部变量表中存放编译期可知的各种基本数据类型(8 种),引用类型( reference), returnaddress 类型的变量。
- 在局部变量表里,32 位以内的类型只占用一个 s1ot(包括引用类型),64 位的类型(1ong 和 double)占用两个 s1ot
- 如果需要访问局部变量表中一个 64bit 的局部变量值时,只需要使用前一个素引即可。(比如:访问 1ong 或 double 类型变量)
- JVM 会为局部变量表中的每一个 S1ot 都分配一个访问素引,通过这个素引即可成功访问到局部变量表中指定的局部变量值
- 方法被编译成字节码指令,并且加载到栈帧中,此时栈帧中只有字节码指令,该栈帧的局部变量表也是空的.然后 cpu 开始执行字节码对应的机器指令:通过把 binpush 指令中的操作数放入到 操作数栈 中,然后再把数值从 操作数栈 中弹出,通过 istore_<局部变量表的index> 命令,把值保存到局部变量对应索引的位置上
  - 案例
    - binpush
    - That value is pushed onto the operand stack.
    - istore_
    - Store int into local variable from top of the operator stack,The must be an index into the local variable array of the current frame
    - astore_
    - Store reference into local variable from top of the operator stack,The must be an index into the local variable array of the current frame
    - ldc2_w
    - Push long or double into operator stack from run-time constant pool (wide index)
    - lstore_
    - Store long into local variable from top of the operator stack
    - ldc
    - Push item into operator stack from run-time constant pool
  - 如果源代码中没有显式赋值,像是 int a;,这样的话栈帧中的局部变量表中没有对应的变量,直至下面代码使用了 a=1,局部变量表才有对应的变量
    - int a;
    - a = 10;
- 如果当前帧是由构造方法或者实例方法创建的,那么当前帧会把该对象发引用 this 将会存放在 index 为 0 的 s1ot 处,其余的参数按照参数表顺序继续排列。
  - 这就可以解释为什么静态方法中是不可以使用 this,是因为静态方法的局部变量表中没有 slot 来存放 this 的值,但是构造方法和实例方法中可以存放 this 的值
- 案例
  - 1. 方法的局部变量保存在局部变量表里(同时局部变量的名字跟局部变量表的序号对应)
  - 1. 方法的形参也会保存在局部变量表
  - 1. slot 的重复利用:栈帧中的局部变量表中的槽位是可以重用的,如果一个局部变量过了其作用域,那么在其作用域之后申明的新的局部变量就很有可能会复用过期局部变量的槽位,从而达到节省资源的目的。

	类变量,成员变量,局部变量的对比
	成员变量		局部变量
	类变量(static)	实例变量	局部变量
声明位置	类中的方法外声明	类中的方法外声明	类中的方法中声明
使用方式	linking 的 prepare 阶段：给类变量默认赋值然后在 initial 阶段：给类变量显式赋值即静态代码块赋值	调用构造方法,随着对象的创建，会在堆空间中分配实例变量空间，并进行默认赋值	使用前，必须要进行显式赋值,否则，编译不通过,因为对于局部变量没有系统初始化过程,必须人为通过代码显式进行设置

局部变量表的性能调优的补充说明
- 在栈帧中,与性能调优关系最为密切的部分就是前面提到的局部变量表。(因为局部变量表中的局部变量会保存堆中的数据的地址,会影响到性能)
- 局部变量表中的变量也是重要的垃圾回收根节点,只要被局部变量表中直接或间接引用的对象都不会被回收。(后面再学)

操作数栈 (就是用数组实现的栈数据结构)
- 引入
  - 每一个独立的栈帧中除了包含局部変量表以外,还包含一个后进先出(Last-In- First-out)的操作数栈,也可以称之为表达式栈 ( Expression Stack)。
    - 注意:这个操作数帧中并不保存编译的指令,只是一个缓存区域用来保存数据
- 概念
  - 操作数栈,主要用于保存计算过程的中间结果,同时作为计算过程中变量临时的存储空间。(比较抽象,看下面的示例)
- 特点
  - 操作数栈,是使用数组实现的栈,根据字节码指令,往操作数栈进行 push 和 pop 数据,操作数栈并非采用访问索引的方式来进行数据访问的,而是只能通过标准的入栈(push)和出栈(pop)操作来完成一次数据访问。(操作数栈中不保存编译后的指令)
  - 操作数栈就是 JVM 执行引擎的一个工作区,当一个方法刚开始执行的时候,一个新的栈帧也会随之被创建出来,这个方法的操作数栈是空的。
    - 证明了一个方法对应着一个操作数栈(如图所示)
  - 每一个操作数栈都会拥有一个明确的栈深度用于存储数值,其所需的最大深度在编译期就定义好了,保存在方法的 code 属性中,为 max_stack 的值
  - 栈中的任何一个元素都是可以任意的 Java 数据类型。32bit 的类型占用一个栈单位深度,64bit 的类型占用两个栈单位深度
  - 在一个方法中调用另外一个方法,那么会先执行别调用的方法,如果被调用的方法带有返回值的话,其返回值将会被压入调用者方法的 操作数栈(不是局部变量栈) 中,并更新 PC 寄存器中下一条需要执行的字节码指令
    - aload_<n>:Load reference from local variable,The local variable at must contain a reference. The objectref in the local variable at is pushed onto the operand stack.翻译:从局部变量表的相应位置装载一个对象引用到操作数栈的栈顶
  - 如果当前方法中调用别的方法,且需要把当前方法中的局部变量传给被调用的方法当做参数,那么传过去的参数会放到被调用的方法的操作数栈
  - 操作数梭中元素的数据类型必须与字节码指令的序列严格匹配,这由编译器在编译器期间进行验证,同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证。
  - 另外,我们说 Java 虚拟机的解释引擎是基于栈的执行引擎,其中的栈指的就是操作数栈
  - 我们源代码中的赋值操作,其中的值都要先放到操作数栈中,然后再从操作数栈弹栈放入到局部变量表中
- 示例(代码追踪)
  1. 源代码
  2. 使用 javap -v OperandStackTest.class 来解析 class 文件
  3. stack=2 就是操作数栈的最大深度(至于为什么,第 6 节会解释)
  4. 使用 jClassLib 分析 class 文件
  5. 作图分析代码执行细节
    - 1. return,方法结束
  6. 通过上面对源码的分析,我们可以看到操作数栈的栈深始终只有 2,方法就可以成功自行完毕.操作数栈的栈深也是在编译后便计算出来,并且生成数组来模拟栈
~~栈顶缓存技术(Top-of-Stack Caching)~~
- 引入
  - 前面提过,基于栈式架构的虚拟机所使用的零地址指令更加紧湊,但完成一项操作的时候必然需要使用更多的入栈和出栈指令,这同时也就意味着将需要更多的指令分派( instruction dispatch)次数和内存读/写次数.而对于基于寄存器指令流来说,数据不用从内存的栈中弹出到 cpu 的寄存器中进行计算,cpu 可以直接根据寄存器的地址进行计算
- 特点
  - 由于操作数是存储在内存中的,因此频繁地执行内存读/写操作必然会影响执行速度。为了解決这个问题, Hotspot JVM 的设计者们提出了機顶缓存(ToS,Top-of- Stack Cashing)技术,将栈顶元素全部缓存在物理 cPU 的寄存器中,以此降低对内存的读/写次数,提升执行引条的执行效率。
动态链接(指向运行时常量的方法的引用)
- 前提
- 概念
  - 每一个栈帧内部都包含一个指向运行时常量池中该栈帧所对应的方法的引用,包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接(Dynamic Linking)。比如: invokedynamic 指令
    - 运行时常量池
      - 就是类文件编译为.class 文件后,通过 javap 命令看到的 常量池Constant pool,然后把 class 文件中的常量池加载到内存中的 方法区 中,此时的 常量池 就被称为 运行时常量池
    - 在 Java 源文件被编译到字节码文件中时,所有的 静态/实例成员变量(不是局部变量) 和 方法引用 都作为符号引用( Symbolic Reference)保存在 c1ass 文件的常量池里。Class 文件的编译过程中，不包含传统程序语言编译的连接步骤。一切方法调用在 class 文件里面存储的都只是符号引用,而不是方法在实际运行时内存布局中的入口地址(也就是说之前说的直接引用)。这个特性，给 Java 带来了强大的动态扩展能力。但也使得 Java 的方法运行的过程中变得相对复杂。某些方法的调用,需要在类加载期间甚至到运行期间才能确定目标方法的直接引用。比如:描述一个方法调用了另外的其他方法时,就是通过常量池中指向方法的符号引用来表示的,那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用。(动态链接是针对方法的符号引用)
      - 我们在写自定义类的方法的时候,编译后的 class 文件可能会使用到很多别类的方法和成员变量,如果我们都把这些方法和成员变量保存到我们自己的 class 文件中,将会导致 class 文件变大的同时,在虚拟机栈中也会出现冗余的内容,浪费空间.所以我们在编译的时候使用符号引用先表示起来,然后运行时通过动态链接来链接到真正的方法和变量
    - 即使这里不明白,也可以看下面这个章节,继续深入理解
方法的调用:解析与分派
- 方法调用并不等同于方法中的代码被执行，方法调用阶段中唯一一个任务是:确定被调用方法的版本(即调用那个方法)。暂时还未涉及方法内部的具体运行过程。 Class 文件的编译过程中，不包含传统程序语言编译的连接步骤。一切方法调用在 class 文件里面存储的都只是符号引用,而不是方法在实际运行时内存布局中的入口地址(也就是说之前说的直接引用)。这个特性，给 Java 带来了强大的动态扩展能力。但也使得 Java 的方法运行的过程中变得相对复杂。某些方法的调用,需要在类加载期间甚至到运行期间才能确定目标方法的直接引用。
- 在 JVM 中,将符号引用转换为调用方法的直接引用与方法的绑定机制相关。
  - 静/动态链接(只是针对方法)
    - 静态链接:当一个字节码文件被装载进 JVM 内部时,如果被调用的目标方法在编译期可知, 且运行期保持不变时。这种情況下将调用方法的符号引用转换为直接引用的过程称之为静态链接。
    - 动态链接:如果被调用的方法在编译期无法被确定下来,也就是说,只能够在程序运行期将调用方法的符号引用转换为直接引用,由于这种引用转换过程具备动态性,因此也就被称之为动态链接。
  - 绑定(针对方法和字段)
    - 绑定 是一个字段、方法或者类在符号引用被替换为直接引用的过程,这仅仅发生一次。绑定 的范围比 链接 的范围大,因为绑定可以针对字段,方法或者类,而链接只是针对方法
      - 早期绑定(对应静态链接):就是指被调用的目标方法如果在编译期可知,且运行期保持不变时即可将这个方法与所属的类型进行绑定,这样一来,由于明确了被调用的目标方法究竟是哪一个,因此也就可以使用静态链接的方式将符号引用转换为直接引用。
      - 晚期绑定(对应动态链接) 如果被调用的方法在编译期无法被确定下来,只能够在程序运行期根据实阿的类型绑定相关的方法,这种绑定方式也就被称之为晚期绑定
- 虚方法和非虚方法
  - 非虚方法
    - 概念
      - 如果方法在编译期就确定了具体的调用版本,这个版本在运行时是不可变的,这样的方法称为非虚方法。(所有在多态中不能被重写的方法就是非虚方法)
        
        补充:多态的前提
        
        类存在继承关系
        
        父类的方法可以被子类重写
    - 分类
      - 静态方法
        
        静态方法不能被子类继承(但是可以被子类调用),自然不存在重写的问题
      - 私有方法
        
        私有方法不能被子类继承,自然不存在重写的问题
      - final 方法
        
        final 修饰的方法不允许重写,但是可以被子类继承
      - 实例构造方法
        
        构造方法不会被子类继承,自然不存在重写的问题
      - 父类自己的方法
        
        当我们在子类中显示调用了 super.method(),自然就是父类自己的方法,肯定不是子类重写后的方法
  - 虚方法
    - 除去非虚方法的方法都是虚方法(子类继承的父类方法全是虚方法)
- 方法的调用
  - 随着高级语言的横空出世,类似于 Java 一样的基于面向对象的编程语言如今越来越多,尽管这类编程语言在语法风格上存在一定的差别,但是它们彼此之间始终保持着一个共性,那就是都支持封装、继承和多态等面向对象特性, ==既然这一类的编程语言具备多态特性,那么自然也就具备早期绑定和晚期绑定两种绑定方式。==
  - Java 中任何一个普通的方法其实都具备虚函数的特征,它们相当于 C++ 语言中的虚函数(C++ 中则需要使用关键字 virtua1 来显式定义)。如果在 Java 程序中不希望某个方法拥有虚函数的特征时,则可以使用关键字 final 来标记这个方法。
- JVM 中提供的调用方法的指令
  - 普通调用指令
    - 调用非虚方法
      - invokestatic:调用静态方法,解析阶段确定唯一方法版本
      - invokespecial:调用子类或者父类的方法、私有及父类方法,解析阶段确定唯一方法版本
    - 调用虚方法(但是也可以调用 final 修饰的非虚方法)
      - invokevirtua1:调用所有虚方法
      - 4, invokeinterface:调用接口方法
  - 动态调用指令
    - 1. invokedynamic:动态解析出需要调用的方法,然后执行
      - JVM 字节码指令集一直比较稳定,一直到 Java7 中才増加了一个 invokedynamic 指令,这是 Java 为了实现「动态类型语言」支持而做的一种改进。
        
        动态类型语言和静态类型语言两者的区别就在于对类型的检查是在编译期还是在运行期,满足前者就是静态类型语言,反之是动态类型语言。
        
        说的再直白一点就是,静态类型语言是判断 变量自身 的类型信息:动态类型语言是判断 变量值 的类型信息,变量没有类型信息,变量值才有类型信息, 这是动态语言的一个重要特征。
        
        对于 int i = 10;,其中 变量i本身 是有类型跟信息的
        
        对于 var i =10,是根据 10 来判断类型信息
      - 虽然在 java7 中引入了这个 invokedynamic 指令,但是在 Java7 中并没有提供直接生成 invokedynamic 指令的方法,需要借助 ASM 这种底层字节码工具来产生 invokedynamic 指令。直到 Java8 的 Lambda 表达式的出现, invokedynamici 指令的生成,在 Java 中才有了直接的生成
      - Java7 中增加的动态语言类型支持的本质是对 Java 虚拟机(JVM)规范的修改,而不是对 Java 语言本身规则的修改,这一块相对来讲比较复杂,增加了 JVM 虚拟机中的方法调用,最直接的受益者就是运行在 JVM 平台的动态语言的编译器(jython,reno)。
  - 总结:前四条指令固化在虚拟机内部,方法的调用执行不可人为干预,而 invokedynamic 指令则支持由用户确定方法版本。其中 invokestatic 指令和 invokespecla 指令调用的方法称为非虚方法,其余的(fina1 修饰的除外)称为虚方法。
- 方法重写的本质(动态分派)
  - 1. 当我们要调用某个方法的时候,(只是调用,尚未运行),我们需要把这个方法对应的对象压入 操作数栈 中,然后把这个对象的类型记录下来,记为 C
  - 2.如果在常量池中找到与 类型C 的描述符和简单名称都相符的方法,则进行访问权限校验,如果通过则返回这个方法的直接引用,查找过程结東;如果不通过,则返回 java.1ang.11 egalaccesserror 异常,查找过程结束。
    - illegalAccessError:程序试图访问或修改一个属性或调用一个方法,这个属性或方法,你没有权限访问。一般的,这个会引起编译器异常。这个错误如果发生在运行时,就说明一个类发生了不兼容的改变。
  - 1. 如果在类型 c 中没有找到与常量池中的描述符和简单名称都相符的方法,则会按照继承关系从下往上以此对 C 的各个父类进行第 2 步的搜索和验证过程
  - 4.如果始终没有找到合适的方法,则抛出 java.1ang. Abstractme thoderror 异常。因为,我们既然要调用该方法,而且从孙子找到爷爷都没有找到该方法,那么这个方法就是抽象方法,没有具体的实现
- 虚方法表
  - 引入
    - 在面向对象的编程中,会很频繁的使用到 动态分派,如果在每次动态分派的过程中都要重新在类的方法元数据中搜索合适的目标的话就可能影响到执行效率。因此,为了提高性能,JVM 采用在类的方法区建立一个虚方法表( virtual method table)(非虚方法不会出现在表中,因为非虚方法不需要重写,一次就可以找到,不需要向上溯源)来实现。使用索引表来代替查找。
  - 特点
    - 每个类中都有一个虚方法表,加载到内存后位于方法区,表中存放着各个方法的实际入口(机器指令在内存中的位置)。
  - 虚方法表什么时候被创建?
    - 虚方法表会在类加载的链接阶段被创建并开始初始化,类的变量初始值准备完成之后,JVM 会把该类的方法表也初始化完毕。
  - 示例
    - 继承关系
    - Dog 的虚方法表
    - CockerSpaniel 的虚方法表
方法返回地址
- 作用
  - 存放调用该方法的指令的下一个指令的地址,以便该方法执行完毕,继续返回到原来的指令的下一条指令继续执行.
- 一个方法的结束,有两种方式
  - 1. 方法正常执行完成.
    - 执行引擎遇到任意一个方法返回的字节码指令( return),如果有返回值,就传递返回值给上层的方法调用者的操作数栈中,否则直接 return,简称正常完成出口
      - ireturn
        
        boolean
        
        btye
        
        char
        
        short
        
        int
      - lreturn
        
        long
      - freturn
        
        float
      - dreturn
        
        double
      - areturn
        
        引用类型
      - return
        
        void
  - 1. 出现了未处理的异常,非正常退出
    - 2、在方法执行的过程中遇到了异常( Ex Caption),并且这个异常没有在方法内进行处理,也就是只要在本方法的 异常表 中没有搜索到匹配的异常处理器,就会导致方法退出。简称异常完成出口
      - 方法执行过程中抛出异常时的异常处理,存储在一个异常处理表,方便在发生异常的时候找到处理异常的代码。
- 无论通过哪种方式退出,在方法退出后都返回到该方法被调用的位置。方法正常退出时,调用者的 pc 计数器的值作为返回地址,即调用该方法的指令的下一条指令的地址。而通过异常退出的,返回地址是要通过异常表来确定,栈帧中一般不会保存这部分信息。
- 本质上,方法的退出就是当前栈帧出栈的过程。此时,需要恢复上层方法的局部变量表、操作数栈、将返回值压入调用者栈帧的操作数機、设置 PC 寄存器值等,让调用者方法继续执行下去。
- 正常完成出口和异常完成出口的区别在于:通过异常完成出口退出的不会给他的上层调用者产生仟何的返回值
一些附加信息
- 主要用来记录 JVM 实现的一些信息,不做了解
栈的相关面试题
- 1. 举例栈溢出的情况
  - 如果虚拟机栈设置的固定大小,如果栈空间不足会发生 StackoverFlowError,如果虚拟机栈设置的是动态大小,当虚拟机栈申请内存失败的时候,会发生 OutOfMemery,我们可以通过修改 -Xss 256G 来设置虚拟机栈的大小
- 1. 调整栈大小,就能保证不出现溢出吗?
  - 不能啊,如果我很多个方法调用呢?直接把虚拟机栈吃满溢出
- 1. 分配的栈内存越大越好吗?
  - 不会的,内存大小不变,导致其他线程的栈内存变小
- 垃圾回收是否会涉及到虚拟机栈?
  - 不会的
- 方法中定义的局部变量是否线程安全?
  - 具体问题具体分析
  - 1. String Builder 内部生成,内部消亡,没有返回出去, 所以线程安全
  - 1. Stringbuilder 是外部传进来的,可能别的线程也在操作该对象, 所以是不安全的

本地方法栈

本地方法接口(JNI)
- 引入
  - 本地方法接口并不是运行时数据区的内容,本地方法栈才是运行时数据区的内容,但是为了后面讲运行时数据区的本地方法栈,我们需要先讲一讲这个本地方法接口
- 什么是本地方法
  - 概念
    - 简单地讲,一个 Native Method 就是一个 Java 调用非 Java 代码的接口。一个 Native Method 是这样一个 Java 方法:该方法的实现由非 Java 语言实现,比如 C。这个特征并非 Java 所特有,很多其它的编程语言都有这一机制,比如在 C++ 中, 你可以用 extern"c"告知 C++ 编译器去调用一个 C 的函数。
  - 特点
    - 在定义ー个 native method 时,并不提供实现体(有些像定义ー个 Java interface),因为其实现体是由非 java 语言在外面实现的。
    - native 是有方法体的实现的,只不过方法提不是 java 实现的
  - 示例
    - 标识符 native 可以与所有其它的 java 标识符连用,但是 abstract 除外。
- 本地接口
  - 本地接口的作用是融合不同的编程语言为 Java 所用,它的初衷是融合 C/C++ 程序。
- 为什么要使用本地方法(NativeMethod)
  - Java 使用起来非常方便,然而有些层次的任务用 Java 实现起来不容易,或者我们对程序的效率很在意时,问题就来了。
  - 与 Java 环境外交互:
    - 有时 Java 应用需要与 Java 外面的环境交互,这是本地方法存在的主要原因你可以想想 Java 需要与ー一些底层系统,如操作系统或某些硬件交换信息时的情况。本地方法正是这样一种交流机制:它为我们提供了一个非常简洁的接口,而且我们无需去了解 Java 应用之外的繁琐的细节。
      - 主要还是因为 java 刚出来的时候 c/c++ 如日中天,所以 java 不能脱离二者,背靠大树好乘凉.
  - 与操作系统交互
    - JVM 支持着 Java 语言本身和运行时库,它是 Java 程序赖以生存的平台,它由一个解释器(解释字节码)和一些连接到本地代码的库组成。然而不管怎样,它毕竟不是一个完整的系统,它经常依赖于一些底层系统的支持。这些底层系统常常是强大的操作系统。通过使用本地方涛我们得以用 Java 实现了 jre 的与底层系统的交互,甚至 JVM 的一些部分就是用 c 写的。还有,如果我们要使用一些 Java 语言本身没有提供封装的操作系统的特性时,我们也需要使用本地方法
  - sun 公司的 java 解释器
    - sun 的解释器是用 C 实现的,这使得它能像一些普通的 C 一样与外部交互。jre 大部分是用 Java 实现的,它也通过一些本地方法与外界交互。例如:类 java.1ang. Thread 的 setpriority()方法是用 JaVa 实现的,但是它实现调用的是该类里的本地方法 setprlority0()。这个本地方法是用 C 实现的,并被植入 JVM 内部,在 Windows95 的平台上,这个本地方法最终将调用网 in32 Setpriority()API。这是一个本地方法的具体实现由 JVM 直接提供,更多的情況是本地方法由外部的动态链接库( external dynamic1ink1 ibrary)提供,然后被 JVM 调用。
- 现状
  - 目前该方法使用的越来越少了,除非是与硬件有关的应用,比如通过 Java 程序驱动打印机或者 Java 系统管理生产设备,在企业级应用中已经比较少见。因为现在的异构领域间的通信很发达,比如可以使用 Socket 通信,也可以使用 Web Service 等等,不多做介绍。
本地方法栈的特点
- Java 虚拟机栈用于管理 Java 方法的调用,而本地方法栈用于管理本地方法的调用。
- 本地方法栈,也是线程私有的。
- 允许被实现成固定或者是可动态扩展的内存大小。(在内存溢出方面是相同的)
  - 如果线程请求分配的栈容量超过本地方法栈允许的最大容量,Java 虚拟机将会抛出一个 stackoverf1 onerror 异常。
  - 如果本地方法可以动态扩展,并且在尝试扩展的时候无法申请到足够的内存,或者在创建新的线程时没有足够的内存去创建对应的本地方法栈,那么 Java 虚拟机将会抛出一个 outofmemoryerror 异常。
- 它的具体做法是 Native Method Stacki 中登记 native 方法,在 Execution Engine 执行时加载本地方法库。
- 当某个线程调用一个本地方法时,它就进入了一个全新的并且不再受虚拟机限制的世界。它和虚拟机拥与同样的权限。
  - 本地方法可以通过本地方法接口来访问虚拟机内部的运行时数据区。它甚至可以直接使用本地处理器中的寄存器直接从本地内存的堆中分配任意数量的内存。
- 并不是所有的 JVM 都支持本地方法。因为 Java 虚拟机规范并没有明确要求本地方法栈的使用语言、具体实现方式、数据结构等。如果 JVM 产品不打算支持 native 方法,也可以无需实现本地方法栈
- 在 Hotspot JVM 中,直接将本地方法栈和虚拟机機合二为一。(但是上面的图不是这样的哦)

堆

1. 堆的核心概述
  - 一个堆和一个方法区都是对应一个 JVM 进程
  - 一个 JVM 进程就对应一个运行时数据区 Runtime(饿汉式单例模式)
  - 一个 JVM 进程内有多个线程,多个线程共享方法区和堆,但是每个线程都有一份 PC 寄存器,本地方法栈,虚拟机栈
- 特点
  - 一个 JVM 实例只存在一个堆内存,堆也是 Java 内存管理的核心区域。
  - Java 堆区在 JVM 启动的时候即被创建,其空间大小也就确定了。是 JVM 管理的最大一块内存空间。
    - 堆内存的大小是可以调节的。
      - -Xms10m:设置堆的初始大小为 10m
      - -Xmx10m:设置堆的最大大小为 10m
    - 我们可以通过一个 JVM 可视化工具 VisualVM 来查看内存的分配,然后按照这里,来配置插件,并且需要挂代理
      - mac 位于 /System/L/Fr/JavaVM.framework/Versions/Current/Commands/jvisualvm,windows 位于 jdk1.8\bin\jvisualvm.exe
  - 《Java 虚拟机规范》规定,堆可以处于物理上不连续的内存空间中,但在逻辑上它应该被视为连续的。
  - 所有的线程共享 Java 堆,在这里还可以划分线程私有的缓冲区( ThreadLocal Allocation Buffer, TLAB),因为如果所有的线程都可以访问堆中所有的空间,会导致线程安全问题,需要使用同步机制来避免线程安全问题,但是同步机制会使得效率降低,所以堆中也划分了各个线程私有的地址(TLAB), 所以说不是堆中所有的部分都可以共享
  - 《Java 虚拟机规范》中对 Java 堆的描述是:所有的对象实例以及数组都应在运行时分配在堆上。但是实际上是:“几乎”所有的对象实例都在这里分配内存。(因为有的对象是没有发生逃逸的,对象的整个生命周期都是在方法中开始结束的,所以可以在栈上分配,而且也只是一个对象的地址而已)
  - 数组和对象可能水远不会存储在栈上,因为栈帧中保存引用,这个引用指向对象或者数组在堆中的位置。(这个结论不一定正确,后面会进一步说明)
    - 代码
    - 堆的示例图
  - 在方法结束后,堆中的对象不会马上被移除,仅仅在垃圾收集的时候才会被移除。(即使方法入栈执行,弹栈结束运行,但是对象并不会立马被释放,可能仍然有别的方法中的局部变量在引用,所以内存的释放是交给 gc 来自动完成的)
  - 堆,是 GC( Garbage Co1 lection,垃圾收集器)执行垃圾回收的重点区域
- 堆的内存细分
  - 现代垃圾收集器大部分都基于分代收集理论设计,堆空间细分为:
    - 前提
    - Java7 及之前堆内存逻辑上分为三部分:新生区 + 养老区 + 永久区(永久区现在都是在方法区做的实现)
      - 新生区(Young Generation Space)
        
        Eden 区
        
        Survivor 区
        
        Survivor 0
        
        Survivor 1
      - 养老区(Old Generation Space)
      - 永久区(Permanet space)
    - Java8 及之后堆内存逻辑上分为三部分:新生区 + 养老区 + 元空间(元空间现在都是在方法区做的实现)
      - 新生区(Young Generation Space)
        
        Eden 区
        
        Survivor 区
      - 养老区(Old Generation Space)
      - 元空间(Meta Space)
        
        从图中可以看到,jdk8 的元空间大小不再受 jvm 进程管理,而是直接位于内存中,jdk7 的永久代还是受到 jvm 的管理的
2, 设置堆内存大小与 OOM
- Java 堆区用于存储 Java 对象实例,那么堆的大小在 JVM 启动时就己经设定好了,大家也可以可以通过选项"-Xmx"和"-Xms"来进行设置
- 默认情况
  - 初始内存大小:物理电脑内存大小/64
  - 最大内存大小:物理电脑内存大小/4
  - 一旦堆区中的内存大小超过“-Xmx"所指定的最大内存时，将会抛出 OutOfMemoryError 异常。
- 自定义
  - Xms 用来设置堆空间(年轻代老年代)的初始内存大小(注意不是 JVM 的内存空间,是堆的内存空间),Xmx 用来设置堆空间(年轻代老年代)的最大内存大小
    - X 是 JVM 的运行参数
    - ms 是 memory start
  - -Xms 用于表示堆区的起始内存,等价于-XX:Initialheapsize
  - -Xmx 则用于表示区的最大内存,等价于-XX: Maxheaps1ze
  - 实际在开发中推荐起始内存和最大内存数量保持一致,省得来回开销内存资源
- 查看堆内存大小
  - 方式 1(查看堆内存的整个过程中,java 进程必须运行)
    - 代码
    - 1. 通过使用 jpa 命令查看当前运行的 java 程序
    - 1. 通过使用 jstat -gc java 进程的id
  - 方式 2(查看堆内存的整个过程中,java 进程必须终止)
    - 1. 在 JVM 的参数中设置 -XX:+PrintGCDetails(+ 表示使用,-表示不使用),并把上面代码后面的线程睡眠的代码去掉,让代码执行完毕后关闭 JVM
    - 1. 程序运行结束后,自动输出图中内容
- OutOfMemory 举例
  - 代码
  - 异常
1. 年轻代和老年代
- 存储在 JVM 中的 Java 对象可以被划分为两类
  - 一类是生命周期较短的瞬时对象,这类对象的创建和消亡都非常迅速
  - 另外一类对象的生命周期却非常长,在某些极端的情況下还能够与 JVM 的生命周期保持一致
- Java 堆区进一步细分的话,可以划分为年轻代( Young Gen)和老年代(O1dGen), 其中年轻代又可以划分为 Eden 空间、 Survivor0 空间和 Survivor1 空间(有时也叫做 from 区、to 区)
- 设置年轻代和老年代在内存中的比例(开发一般不会调)
  - 默认
    - -XX:NewRatio=2,表示新生代占 1,老年代占 2,新生代占整个堆的 1/3,可以通过 jinfo -flag NewRatio java进程id 命令来查看这个比值
  - 自定义
    - 可以修改 -XX: NewRatlo=4,表示新生代占 1,老年代占 4,新生代占整个堆的 1/5
  - 补充
    - 使用 -Xmn 可以指定新生代的最大内存大小,这就和我们上面设定的比例冲突了,当二者冲突的时候,以 -Xmn 为准,因为其指定了特定的数值,但是平时开发我们不使用这个参数,我们更多的使用的是比例的形式来确定新生代和老年代的比例
- 设置新生代的 Eden 空间和 Survivor0/1 空间的大小
  - 默认
    - eden:survivor0:survivor1=8:1:1,可以通过命令 jinfo -flag SurvivorRation java进程id,但是在实际的堆中,并不是这么分配,分配的比例是 6,如果我们想要默认的 8,我们必须手动设置比例为 8
      - 堆的大小为 600M,默认老年代/新生代=2,所以新生代大小为 200M,然后 eded:survivor0:survivor1=8:1:1,但是从图中看出 eden 占据 150M,survivor0/1 各占据 25M,这样比例是 6:1:1,不符合默认的结果,这是因为 JVM 内部有一个 -XX:+UseAdaptveSizePolicy,开启了内存自适应,但是我们使用 -XX:-UseAdaptveSizePolicy 关闭该选项,重新查看内存,发现没什么变化,我们只能通过-XX:SurvivorRation=8 来设置,结果在下面
  - 自定义
    - -XX:SurvivorRatio=8
- 新生代的特点
  - 几乎所有的 Java 对象都是在 Eden 区被 new 出来的
  - 绝大部分的 Java 对象的销毁都在新生代进行了
1. 图解对象分配内存过程
- 引入
  - 为新对象分配内存是一件非常严谨和复杂的任务,JVM 的设计者们不仅需要考虑内存如何分配、在哪里分配等问题,并且由于内存分配算法与内存回收算法密切相关,所以还需要考虑 GC 执行完内存回收后是否会在内存空间中产生内存碎片
- 图解对象分配过程
  - 1. new 的对象先放伊甸园区。此区有大小限制。
  - 1. 当伊甸园的空间填满时,程序又需要创建对象,JVM 的垃圾回收器将对伊甸园区进行垃圾回收( Minor GC/yong gc),将伊甸园区中的不再被其他对象所引用的对象进行销毁,同时把伊甸园区中还存在索引的对象放到幸存者区,两个幸存者区域,谁空放在谁那里,刚开始两个幸存者区都是空的,那就随便放一个,比如说是 Survivor0 吧,放到幸存者区的对象都会有一个 age 的计数器,此时 age++,然后再加载新的对象放到伊甸园区,
  - 1. 如果接下来伊甸园内存满了,再次触发 YGC 垃圾回收,此时 YGC 会判断伊甸园区中仍然存在引用的对象,也会判断 from 幸存者区中的仍然存在引用的对象。会把这两个区中的仍存在引用对象都放入到 to 幸存者区,对于这个两个区不存在索引对象全部释放,并把放到 to 幸存者区的对象的 age 都加 1。(规定了 to 幸存者区是空的,From 幸存者区不是空的)
  - 1. 当再次触发 YGC 垃圾回收的时候。首先把伊甸园区仍然存在索引的对象，放入到 to 幸存者区,并 age++。再找出 from 幸存者中仍然存在索引的对象,并判断对象的 age 属性是否为 15。如果是 15 则放入到老年区,如果不是 15,则放入到 to 幸存者区,并 age++
  - 1. 对象在养老区相对悠闲。当养老区内存不足时,再次触发 GC: Major GC,进行养老区的内存清理。
  - 1. 若养老区执行了 Major GC 之后发现依然无法进行对象的保存,就会产生 OOM 异常
- 频繁在新生区 gc,很少在老年区 gc,几乎不在永久区/元空间 gc
- 思考
  - 1. 我们知道伊甸园去买了会触发 YGC 垃圾回收。那么 from 幸存者区满了,会触发 YGC 垃圾回收吗?
    - 不会触发,YGC 垃圾回收只有伊甸园满了才能触发,但是 YGC 会回收伊甸园和幸存者区所有没有索引的对象.
  - 1. 那么如果 to 区放不下 from 区 + 伊甸园区的对象怎么办?
    - 直接把 from 区的部分对象放到老年区,即使对象的 age 并没有达到 15
  - 1. 有没有对象一出生就是在老年代
    - 有
      - 大对象直接分配到老年代
        
        因为生成一个大对象,要放到 Eden,但是 Eden 内存不够,触发 YGC,但是 YGC 后,Eden 为空仍然放不下大对象,既然空的 Eden 都放不下,那么 Survivor 就更不用说了,所以只能放到老年代
        
        尽量避免程序出现过多的大对象,因为大对象往往需要 GC 去工作,导致 STW,然后万一生成的大对象居然是朝生夕死的,那就跟难受了
  - 1. 设置 from/to 幸存区的意义是什么
    - 防止出现碎片
  - 1. 如何设置去老年区的阈值
    - 使用 Xx: MaxTenuringThresho1d=<N> 进行设置
- 总结
  - 针对幸存者 s0,s1 区的总结:复制之后有交换,谁空谁是 to
  - 关于垃圾回收:频繁在新生区收集,很少在养老区收集,几乎不在永久区/ 元空间收集。
- 内存分配的特殊情况
- 常用调优工具
1. Minor GC、 Maior GC、 Full GC
- gc 调优就是要减少 gc 的次数,因为 gc 在工作时,会暂停我们的用户线程,只让 gc 线程工作
- JVM 在进行 Gc 时,并非每次都对上面三个内存(新生代、老年代;方法区)区域一起回收的,大部分时候回收的都是指新生代。
- 针对 Hotspot VM 的实现,它里面的 GC 按照回收区域又分为两大种类型
  - 部分收集(Partial GC):不是完整收集整个 Java 堆的垃圾收集
    - 新生代收集( Minor Gc/ Young Gc):只是新生代(Eden,s0/1)的垃圾收集
    - 老年代收集( Major Gc/o1dGC):只是针对老年代的垃圾收集。然而事实上 MajorGC 会收集不只是老年代的垃圾,,有点 FullGC 的意思,所以目前只有 CMS GC 才会只收集老年代.
    - 混合收集( Mixed GC):收集整个新生代以及部分老年代的垃圾收集。目前,只有 G1 GC 会有这种行为,因为 G1 GC 的内存划分是按照区域进行的,一个区域既包含老年区,也包含新年区
  - 整堆收集(Full GC)
    - 收集整个 java 堆和方法区的垃圾收集。
- 新生代(Minor GC)
  - 触发机制
    - 当年轻代空间不足时,就会触发 Minor GC,这里的年轻代满指的是 Eden 代满, Survivor 满不会引发 GC(会把 s0/1 的对象放入到老年代中),因为幸存者区的垃圾回收是跟 eden 区一起被动回收。(每次 Minor GC 会清理年轻代的内存(包括 eden+s0+s1)。)
  - 采用算法
    - MinorGC 采用复制算法
      - 1： eden、 servicorFrom 复制到 ServicorTo，年龄 +1
        
        首先，把 Eden 和 ServivorFrom 区域中存活的对象复制到 ServicorTo 区域（如果有对象的年龄以及达到了老年的标准，则赋值到老年代区），同时把这些对象的年龄 +1（如果 ServicorTo 不够位置了就放到老年区）；
      - 2：清空 eden、 servicorFrom
        
        然后，清空 Eden 和 ServicorFrom 中的对象；
      - 3： ServicorTo 和 ServicorFrom 互换
        
        最后， ServicorTo 和 ServicorFrom 互换，原 ServicorTo 成为下一次 GC 时的 ServicorFrom 区。
  - 特点
    - 因为]ava 对象大多都具备朝生夕灭的特性,所以 Minor GC 非常频繁,一般回收速度也比较快。这一定义既清晰又易于理解。
    - Minor GC.会引发 sTW(stop to work),暂停其它用户的线程,等垃圾回收结束,用户线程才恢复运行。
- 老年代 GC( Major Gc/Fu11GC):
  - 触发机制
    - 当老年代空间不足的时候,就会出发 major gc
  - 采用算法
    - MajorGC 采用标记清除算法
      - 首先扫描一次所有老年代，标记出存活的对象，然后回收没有标记的对象。 MajorGC 的耗时比较长，因为要扫描再回收。 MajorGC 会产生内存碎片，为了减少内存损耗，我们一般需要进行合并或者标记出来方便下次直接分配。当老年代也满了装不下的时候，就会抛出 OOM（Out of Memory）异常。
  - 特点
    - 指发生在老年代的 GC,对象从老年代消失时,我们说“ Major Gc”或“Fu11GC"发生了
    - 出现了 Major Gc,经常会伴随至少一次的 Minor GC(但非绝对的,在 Paralle1Scavenge 收集器的收集策略里就有直接进行 Major Gc 的策略选择过程)
    - 也就是在老年代空间不足时,会先尝试触发 Minor Gc。如果之后空间还不足, 则触发 Major GC,如果 Major Gc 后,内存还不足,就报 OOM 了。
    - Major GCE 的速度一般会比 Minor Gct 慢 1 倍以上。
- Full GC
  - 触发机制(五种情况)
    - (1)调用 System.gc()时,系统建议执行 Fu11GC,但是不必然执行
    - (2)老年代空间不足
    - (3)方法区空间不足
    - (4)通过 Minor GC 后进入老年代的平均大小大于老年代的可用内存
    - (5)由 Eden 区、 survivor spacee( From Space)区向 survivor space1(ToSpace)区复制时,对象大小大于 To Space 可用内存,则把该对象转存到老年代,且老年代的可用内存小于该对象大小
  - 特点
    - fu11gc 是开发或调优中尽量要避免的。这样暂时时间会短一些。
1. 堆空间分代思想
- 为什么需要把堆分代?不分代就不能正常工作了吗?
  - 经研究,不同对象的生命周期不同。80% 的对象是临时对象。如果不进行分代,所有的对象都放在堆内存中,,GC 的时候就需要对所有的对象进行扫描,然而很多对象都是朝生夕死的,我们可以利用分代,把他们统一放到某一个地方,方便 GC 对他们快速进行回收,而且直接快速腾出很大的空间.所以说分代的唯一理由就是优化 GC 的性能
1. 内存分配策略
- 一般情况下的内存分配策略
  - 如果对象在 Eden 出生并经过第一次 Minorgc 后仍然存活,并且能被 Survivor 容纳的话,将被移动到 Survivor 空间中,并将对象年龄设为 1。对象在 Survivor 区中每熬过一次 MI norgc,年龄就増加 1 岁,当它的年龄増加到一定程度(默认为 15 岁,其实每个 JVM、每个 GC 都有所不同)时,就会被晋升到老年代
- 全买的内存分配策略
  - 1. 优先分配到 Eden
  - 1. 大对象直接分配到老年代
    - 因为生成一个大对象,要放到 Eden,但是 Eden 内存不够,触发 YGC,但是 YGC 后,Eden 为空仍然放不下大对象,既然空的 Eden 都放不下,那么 Survivor 就更不用说了,所以只能放到老年代
    - 尽量避免程序出现过多的大对象,因为大对象往往需要 GC 去工作,导致 STW,然后万一生成的大对象居然是朝生夕死的,那就跟难受了
  - 1. 长期存活的对像分配到老年代
  - 1. 动态对象年龄判断
    - 如果 Survivor 区中相同年龄的所有对象大小的总和大于 Survivor 空间的一半,年龄大于或等于该年龄的对象可以直接进入老年代,无须等到 Maxtenuringthresho1d 中要求的年龄。
  - 1. 空间分配担保:-XX: Handlepromotionfailure,意思是如果 Eden 往 Survivor 中转移对象时,如果 Survivor 装不下的时候,对象会直接存放到老年代,(详细的解释,在后面的小结堆空间的参数设置有解释)
1. 为对象分配内存:TLAB
- 引入
  - 为什么有 TLAB( Thread Local Allocation Buffer)?
    - 堆区是线程共享区域,任何线程都可以访问到堆区中的共享数据,由于对象实例的创建在 JVM 中非常频繁,因此在并发环境下从堆区中划分内存空间给线程用来创建新的对象是线程不安全的,有可能多个线程同时操作同一个地址,为避免多个线程操作同一地址,需要使用加锁等机制,进而影响分配速度。
- 什么是 TLAB(Thread Local Allocation Buffer)
  - 从内存模型而不是垃圾收集的角度,对 Eden 区域继续进行划分,JVM 为每个线程分配了一个私有缓存区域,它包含在 Eden 空间内。
- 特点
  - 多线程同时分配内存时,使用 TIAB 可以避免一系列的非线程安全问题, 同时还能够提升内存分配的吞吐量,因此我们可以将这种内存分配方式称之为快速分配策略。
  - 尽管不是所有的对象实例都能够在 TLAB 中成功分配内存(因为 TLAB 大小实在太小了),但 JVM 确实是将 TLAB 作为内存分配的首选。
  - 且对象在 TLAB 空间分配内存失败时(对象太大,或者 TLAB 本身剩余空间不足),JVM 就会尝试着通过使用加锁机制(给 edge 加锁)确保数据操作的原子性,从而直接在 Eden 空间中分配内存(并发性降低)。
  - 在程序中,开发人员可以通过选项“-XX: UseTLAB”设置是否开启 TLAB 空间
  - 默认情况下,TLAB 空间的内存非常小,仅占有整个 Eden 空间的百分之一,当然我们可以通过选项“-XX: TLABWasteTargetPercent”设置 TLAB 空间所占用 Eden 空间的百分比大小。(具体设置,查看 jvm 的说明)
1. 小结堆空间的参数设置
- -XX:+PrintFlagsInitial:査看所有的参数的默认初始值
- -XX:+PrintFlagsFinal:查看所有的参数的最终值(可能会存在修改,不再是初始值)
  - 我们在之前也学习过一种方法每次可以查看一个参数的值
    - 1. 程序在运行的时候,输入命令 jps
    - 1. 通过使用 jinfo -flag SurvivorRatio java进程id,来查看 SurvivorRation 具体的值
- -Xms:初始堆空间内存(默认为物理内存的 1/64)
- -Xmx:最大堆空间内存(默认为物理内存的 1/4)
- -Xmn:设置新生代的大小。(初始值及最大值)
- -XX: NewRatio:配置新生代与老年代在堆结构的占比
- -XX: SurvivorRatio:设置新生代中 Eden 和 s0/S1 空间的比例,默认值为 8
  - 如果 Eden 比例过大,导致 Survivor 区过小会发生什么?
    - 当 Eden 满的时候,进行 YGC,但是 Survivor 过小,导致对象都被放到老年代,那么分代的意义就没了,就导致 gc 效率降低了
  - 如果 Survivor 比例过大,导致 Eden 区过小会发生什么?
    - 会经常进行 YGC
- -XX: MaxTenuringThreho1d:设置新生代垃圾的最大年龄,默认值为 15
- -XX:+PrintGCDetails:输出详细的 GC 处理日志 ②- verbose:gc
  - 打印 gc 简要信息
    - -XX:+PrintGC
    - -verbose:gc
- -XX: Handlepromotionfailure:是否设置空间分配担保
  - jdk7 以前步骤
    - 在发生 Minor GC 之前,虚拟机会检査老年代 最大可用的连续空间 是否大于新生代所有对象的总空间。
      - 如果大于,则此次 Minor GC 是安全的
      - 如果小于,则虚拟机会查看 -XX: Handle PromotionfFai1ure 设置值是否允许担保失败。
        
        如果 Handlepromotionfai1ure=true,那么会继续检查老年代最大可用连续空间是否大于之前每一次晋升到老年代时的对象总和的平均大小。
        
        v 如果大于,则尝试进行一次 Minor GC,但这次 Minor GC 依然是有风险的(因为之前比较的是平均情况,所以有风险)
        
        如果小于,则改为进行一次 Fu11GC。
  - jdk7 之后步骤
    - 在 JDK6 Update24 之后(JDK7), Handlepromotionfai1ure 参数不会再影响到虚拟机的空间分配担保策略,观察 PENJDKI 中的源码变化,虽然源码中还定义了 Handllepromotionfai1ure 参数,但是在代码中已经不会再使用它。
    - JDK6 Update24 之后的规则变为只要老年代的连续空间大于新生代对象总大小或者历次晋升的平均大小就会进行 Minor GC,否则将进行 Fu11Gc。
1. 堆是分配对象的唯一选择吗
- 引入
  - 在《深入理解 Java 虚拟机》中关于 Java 堆内存有这样一段描述:随着 JIT 编译期的发展与逃逸分析技术逐渐成熟,栈上分配、标量替换优化技术将会导致一些微妙的变化,所有的对象都分配到堆上也渐渐变得不那么“绝对”了。
  - 在 Java 虚拟机中,对象是在 Java 堆中分配内存的,这是一个普遍的常识。但是,有种特殊情况,那就是如果经过逃逸分析( Escape Analysis)后发现,一个对象并没有逃逸出方法的话,那么就可能被优化成栈上分配。这样就无需在堆上分配内存,也无须进行垃圾回收了。这也是最常见的堆外存储技术。
  - 此外,前面提到的基于 OPENUDK 深度定制的 TAOBAOVM,其中创新的 GCIH(GCinvisible heap)技术实现。off-heap,将生命周期较长的 Java 对象从 heap 中移至 heap 外(仍然是内存中的某个地方,但是不是堆),并且 GC 不能管理 GCIH 内部的 Java 对象,以此达到降低 Gc 的回收频率和提升 GC 的回收效率的目的。
- 逃逸分析
  - 目的:把对象从堆分配到栈上
  - 概念
    - 这是一种可以有效减少 Java 程序中 同步负载 和 内存堆分配压力的跨函数全局数据流分析算法。
  - 作用
    - 通过逃逸分析, Java Hotspot 编译器能够分析出一个新的对象的引用的使用范围从而决定是否要将这个对象分配到堆上。
  - 基本行为(就是分析对象的作用域)
    - 当一个对象在方法中被定义后,对象只在方法内部使用,则认为没有发生逃逸。
    - 当一个对象在方法中被定义后,它被外部方法所引用,则认为发生逃逸。例如作为方法内部生成一个对象然后把该对象作为参数传递到其他地方中或者我们在方法中生成的对象然后 return 到方法外部
  - 如何快速的判断是否发生了述途分折,大家就看 new 的对象实体(static 修饰的也会发生逃逸)是否有可態在方法外被调用
  - 案例分析
    - 案例 1
      - 对象 v 只是在方法内部被声明使用销毁,所以我们可以放到该方法的栈帧中,这样,别的线程访问不到,不担心线程安全问题,同时也不用担心 GC 的问题,因为随着方法执行结束,栈帧被弹出,栈帧空间全被释放了,没有 gc 的工作了
    - 案例 2
    - 案例 3:包含了所有的逃逸分析
  - 参数设置
    - jdk7 以后,HotSpot 默认开启了逃逸分析
    - jdk7 以前,可以通过 -XX:+DoEscapeAnalysis 显示开启逃逸分析,并启动栈上分配,然后通过选项 -XX:+PrintEscapeAnalysis 查看逃逸分析的筛选结果
  - 结论
    - 开发中能使用局部变量的,就不要再发方法外部定义
  - JIT 编译器针对逃逸分析所做的优化
    - 1. 栈上分配
      - 将堆分配转化为栈分配。如果一个对象在子程序中被分配, 要使指向该对象的指针永远不会逃逸,对象可能是栈分配的候选,而不是堆分配
      - 实现原理
        
        JT 编译器在编译期间根据逃逸分析的结果,发现如果一个对象并没有逃逸出方法的话,就可能被优化成栈上分配。分配完成后,继续在调用機内执行,最后线程结束,栈空间被回收,局部变量对象也被回收。这样就无须进行垃圾回收了。
      - 特点
        
        不用 gc 参与
        
        而且内存分配速度极快
        
        但是如果在栈中分配大量对象,可能出现对象数量无法达到我们规定的数量,但是在堆中分配,数量肯定满足我们规定的数量
        
        其实栈上分配的本质就是利用了下面即将讲到的 标量替换 功能,即为==栈上分配本质上并不直接保存整个对象本身,而是把对象这个聚合量全都分配成标量,把对象拆散开放到栈中.所以栈上分配内存就是假的==
        
        那为什么我们一开始没有开启 标量替换,只开启了 逃逸分析和栈上分配 也会有"栈上分配"的感觉呢?
        
        因为标量替换这个就是默认开启的,所以我们所谓的"栈上分配",就是 变量替换
    - 1. 同步省略
      - 引入
        
        线程同步的代价是相当高的,同步的后果是降低并发性和性能。
      - 概念
        
        如果一个对象被发现只能被一个线程访问,那么对于这个对象的操作可以不考虑同步
      - 实现原理
        
        在动态编译同步块的时候,JIT 编译器可以借助 逃逸分析 来判断同步块所使用的锁对象是否只能够被一个线程访问而没有被发布到其他线程。如果没有,那么 JIT 编译器在编译这个同步块的时候就会取消对这部分代码的同步。这样就能大大提高并发性和性能。这个取消同步的过程就叫 同步省略,也叫 锁消除。
      - 案例:
        
        但是我们在使用 jClassLIb 查看 class 文件的时候,会 jvm 的指令仍然包含 Synchronized 关键字,是因为 JIT 编译器在优化的时候是对加载近内存的 class 文件进行优化是,在加载完 class 文件后代码真正执行前进行优化的
    - 1. 分离对象或标量替换
      - 引入
        
        对于所有的语言来说,有的对象可能不需要作为一个连续的内存结构存在也可以被访问到,那么对象的部分(或全部)可以不存储在内存,而是存储在 CPU 寄存器中
        
        对于 JAVA 来说,有的对象可能不需要作为一个连续的内存结构存在堆中也可以被访问到,那么对象的部分(或全部)可以不存储在内存,而是存储在内存的栈中(因为 java 的指令流是基于栈的)
      - 前提
        
        标量:是指一个无法再分解成更小的数据的数据。Java 中的 基本数据类型 就是标量
        
        聚合量:是指一个变量还可以继续分解,比如:java 的对象就是一个聚合量,因为他可以分解成其他聚合量和标量
      - 具体实现
        
        在 JIT 阶段,如果经过逃逸分析,发现一个对象不会被外界访问的话,那么经过 JIT 优化,就会把这个对象拆解成若干个其中包含的若干个成员变量来代替。这个过程就是标量替换。
      - 参数设置
        
        -XX:+EliminateAllocations:开启标量替换(默认就是开启的),允许把对象打散分配在栈上
      - 案例
        
        源代码
        
        编译后的源代码
        
        分析
        
        可以看到, Point 这个聚合量经过逃逸分析后,发现他并没有逃逸,就被替换成两个标量了。那么标量替换有什么好处呢?
        
        就是可以大大减少堆内存的占用。因为不需要创建对象了,那么就不再需要分配堆内存了。
        
        标量替换为栈上分配提供了很好的基础。(一看二者就有交易)
    - 总结
      - 所以对象只会分配到堆上吗?是的
        
        是因为逃逸分析存在一个根本问题
        
        其根本原因就是无法保证逃逸分析的性能消耗一定能高于他的消耗。虽然经过逃逸分析可以做标量替换、栈上分配、和锁消除。但是逃逸分析自身也是需要进行一系列复杂的分析的,这其实也是一个相对耗时的过程。极端的例子,就是经过逃逸分析之后,发现没有一个对象是不逃逸的。那这个逃逸分析的过程就白白浪费掉了。
        
        通过逃逸分析的确可以实现整个对象分配在栈空间上(不是利用标量替换这种把对象拆散了),但是这样付出的性能代价有些得不偿失,所以 HotSpot JVM 默认没有实现这个逃逸分析,所以说对象一定是分配在堆上的

方法区

1. 栈,堆,方法区的交互关系
- 前提
  - 1. 方法区在运行时数据区的结构体系
- 栈,堆,方法区的交互关系
1. 方法区的理解
- 方法区的定义
  - jvm 规范手册
    - 尽管所有的方法区在逻辑上是属于堆的一部分,但
      一些 jvm 的简单的实现可能不会选择去对方法区进行垃圾收集或者进行压缩。”
  - Hotspot jvm
    - 但对于 Hotspotjvmi 而言,方法区还有一个别名叫做 Non-Heap(非堆),目的就是要和堆分开。方法区是一个独立于 java 堆的内存空间
- 特点
  - 方法区( Method Area)与 Java 堆一样,是各个线程共享的内存区域,比如说在类的加载方面,如果有一个类没有被加载进来,但是却又多个线程去访问该类,那么我们只需要一个线程区加载该类到内存
  - 方法区在 JVM 启动的时候被创建,并且它的实际的物理内存空间中和 Java 堆区一样都可以是不连续的,但是逻辑上要求连续.
  - 方法区的大小,跟堆空间一样,可以选择固定大小或者可扩展。
  - 方法区的大小决定了系统可以保存多少个类,如果系统定义了太多的类,导致方法区溢出,虚拟机同样会抛出内存溢出错误:java.lang. outofmemoryerror:Permgen space 或者 java.lang.Outofmemoryerror: Metaspace
    - 加载大量的第三方的 ja ェ包: Tomcat 部署的工程过多(30-50 个);大量动态的生成反射类
  - 关闭 JVM 就会释放这个区域的内存。
- Hotspot 中方法区的演变
  - 在 jdk7 及以前,习惯上把方法区,称为永久代。jdk8 开始,使用元空间取代了永久代。==相当于永久代和元空间都是 java 虚拟机中的具体实现==
  - 本质上来说,永久代 和 元空间 并不是等价的,因为这个只是 hotspot jvm 自己这么使用的,别的 jvm 如 rockitjvm 这没有永久代的概念,他们只把方法区实现为元空间,hotspot 在 jdk8 之后,也把方法区叫做元空间,并废除掉永久代
  - jdk8 中的方法区叫做元空间,但是该元空间占据的内存不是 jvm 进程分配的内存,而是直接占用本地的内存,但是永久占据的却是 jvm 的内存,导致经常 OOM
  - 永久代、元空间二者并不只是名字变了,内部结构也调整
  - 根据《Java 虚拟机规范》的规定,如果方法区无法满足新的内存分配需求时,将抛出 OOM 异常。(即为用户的整个内存都不够用了)
1. 设置方法区大小与 OOM
- 方法区不像堆一样,堆的内部又可以分为很多区域,方法区域是一个逻辑上整体
- 方法区的大小既可以是固定大小,也可以是自动扩充自动压缩的(自动分配大小就不说了,说一下如何分配固定的大小)
- jdk7 及其以前
  - 通过-XX: Permsize 来设置永久代初始分配空间。默认值是 20.75M
  - 通过-XX: Maxpermsize 来设定永久代最大可分配空间。32 位机器默认是 64M,64 位机器模式是 82M
  - 当 JVM 加载的类信息容量超过了这个值,会报异常 Outo fmemoryerror: PermgenSpace
- jdk8 及其以后
  - 通过使用 -XX:MetaspaceSize 来设置元空间的初始分配空间,元空间默认初始值默认依赖于平台,对于 Windows 来说,-XX:MetaspaceSize 默认值约为 21M,-XX:MaxMetaspaceSize 默认值为-1,表示最大值不受限制,直到整个内存空间都不足
  - 与永久代不同,如果不指定大小,默认情況下,虚拟机会耗尽所有的可用系统内存如果元数据区发生溢出,虚拟机一样会抛出异常 Outofmemoryerror: Metaspace
  - 开发中,我们会手动把 -XX:MetaspaceSize 设置的比较高,而不是默认的,因为如果默认过低,会多次触发 Full GC,然后 jvm 会自动根据回收的类来更改这个默认的元空间的大小.与其多次调用 fullgc 且会自动对默认元空间大小进行更改,不如我们一开始就设置一个较大的值
- OOM
  - 分类
    - OOM:heap
    - OOM:metaspace
  - 解决 OOM 的步骤
    - 1. 先使用内存映像分析工具分析内存,判断是内存泄露还是内存溢出,因为二者都会导致 OOM
      - 内存泄露:程序员自己的问题,创建了对象,实际中不去使用,但是又不释放内存,导致占据内存
      - 内存溢出:就是单纯的堆空间余量不足,所需要的空间内存无法提供,或者是超过了我们限制的最大堆空间
    - 1. 我们首先需要判断 OOM 是不是由于内存泄露导致的呢:==即为查看内存中的对象是否都需要存活着==如果是内存泄漏,可进一步通过工具査看泄漏对象到 GC Roots 的引用链。于是就能找到泄漏对象是通过怎样的路径与 GC Roots 相关联并导致垃圾收集器无法自动回收它们的。掌握了泄漏对象的类型信息,以及 GC Roots 引用链的信息,就可以比较准确地定位出泄漏代码的位置。
    - 1. 如果不是内存泄露,那就应当检査虚拟机的堆参数(-Xmx 与-Xms),与机器物理内存对比看是否还可以调大,从代码上检査是否存在某些对象生命周期过长、持有状态时间过长的情況,尝试减少程序运行期的内存消耗。
1. 方法区的内部结构
- 方法区内部结构
- 深入理解 java 虚拟机一书中:方法区用于存储已被虚拟机加载的类型信息、常量、静态变量、即时编译器编译后的代码缓存等
  - 类型信息
    - 对每个加载的类型(类 c1ass、接口 interface、枚举 enum、注解 annotation),JVM 必须在方法区中存储以下类型信息:
      - 这个类型的完整有效名称(全名=包名.类名)
      - 这个类型直接父类的完整有效名(对于 interface!或是 java.1ang. Object,都没有父类)
      - 这个类型的修饰符( public, abstract,fina1 的某个子集)
      - 这个类型直接接口的一个有序列表
  - 域信息(Field,类变量和成员变量)
    - JVM 必须在方法区中保存类型的所有域的相关信息以及域的声明顺序。
      - 域的相关信息包括:域的声明顺序,域名称、域类型、域修饰符(public, private protected, static,fina1, volatile, transient 的某个子集)
    - 需要指出的是 类变量位于方法区 中(图中都画出来了 静态变量)
      - 类变量是给整个 Class 来用的,如果放在堆中,不就容易被 gc 了吗?
  - 静态变量
  - 方法(Method)的信息
    - JVM 必须保存所有方法的以下信息,同域信息一样包括声明顺序
      - 方法名称
      - 方法的返回类型(或 void 类型,void 也是有对应的 class 文件的)
      - 方法参数的数量和类型(按顺序)
      - 方法的修饰符(pub1ic, private, protected, static,fina1, synchronized, native, abstract 的一个子集)
      - 方法的字节码( bytecodes)、操作数栈、局部变量表及大小( abstract 和 native 方法除外)
      - 异常表( abstract 和 native 方法除外)
        
        每个异常处理的开始位置、结束位置、代码处理在程序计数器中的偏移地址、被捕获的异常类的常量池索引
  - 运行时常量池
    - 磁盘中.class 文件中的常量变成了内存中的运行时常量
  - JIT 代码缓存
- 示例:注意使用命令 javap -v -p MethodInnerStrucTest,-p 的意思 private 修饰的对象也能显示出来 (.class 文件就是被加载进入 jvm 的方法区,所以这里分析.class 文件就可以知道方法区的内容)
- 补充:non-finnal 类变量
  - 静态变量和类关联在一起,随着类的加载而加载,它们成为类数据在逻辑上的一部分。
  - 类变量被类的所有实例共享,即使没有类实例时你也可以访问它。
  - 如果类变量被 final 修饰呢?
    - 结论
      - 被声明为 fina1 的类变量的处理方法则不同,每个全局常量在编译的时候就会被分配了
- 各种常量池
  - 字符串运行时常量池 vs 字符串常量池
    - 运行时常量池位于方法区内部(后来字符串常量池转移到了堆中),运行时常量池来自于 class 文件中的字节码文件,但是所以我们需要看得懂字节码文件,才能看懂常量池,才能看懂运行时常量池
    - 分析常量池
      - 一个有效的字节码文件中除了包含类的版本信息、字段、方法以及接口等描述信息外,还包含一项信息那就是常量池表( Constant Poo1 Table),常量池表包括各种字面量的值和类型、域和方法的符号引用,。(符号引用就是相当于一个占位符,然后真正进入到内存中的时候再转换成真正的链接)
      - 为什么需要常量池?
        
        一个 java 源文件中的类、接口,编译后产生一个字节码文件。而 Java 中的字节码需要别的数据支持(如 Object,System),通常这种数据会很大以至于不能直接存到一个字节码文件里,如果每个字节码文件都存一份该数据,就会太冗余,所以换另一种方式,可以把这些数据的符号引用存到常量池中, 在动态链接的时候会用到运行时常量池,之前有介绍。
        
        常量池避免了频繁的创建和销毁对象而影响系统性能,其实现了对象的共享
      - 常量池中有什么?
        
        字面量
        
        final 修饰的常量
        
        基本数据类型的值
        
        字符串的值(注意不是 String 对象)
        
        符号引用
        
        类引用
        
        字段引用
        
        方法引用
      - 总结
        
        常量池,可以看做是一张表,虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等类型
    - 分析运行时常量池
      - 运行时常量池( Runtime Constant Poo1)是方法区的一部分。
      - 常量池表( Constant Poo1Tab1e)是 c1ass 文件的一部分,用于存放编译期生成的各种字面量与符号引用,这部分内容将在类加载后存放到方法区的运行时常量池中.
      - 运行时常量池,在加载类和接口到虚拟机后,就会创建对应的运行时常量池。
      - JVM 为每个已加载的类型(类或接口)都维护一个常量池。池中的数据项像数组项一样, 是通过索引访问的。
      - 运行时常量池中包含多种不同的常量,包括编译期就已经明确的数值字面量,也包括到运行期解析后才能够获得的方法或者字段引用。此时不再是常量池中的符号地址了,这里换为真实地址。
      - 运行时常量池相对于 Class 文件中的常量池的另一个重要特征就是:具备动态性.运行时常量池中的内容,可以在运行期间进行修改其中的内容,如 String.intern() 可以向运行时常量池中放入我们自定义的字符串
  - Integer 常量池
    - 引入
      - 装箱
        
        装箱:把值类型转为引用类型,装箱过程是通过调用包装类的 valueOf 方法实现的
      - 拆箱
        
        拆箱:把引用类型转为值类型,拆箱过程是通过调用包装器的 xxxValue 方法实现的。（xxx 代表对应的基本数据类型,比如 Integer.intValue()来拆箱）
    - 案例
      - 源码
      - 对于 i1 == i2
        
        由于这两个变量都使用了 new Integer(),所以在堆中新建了两个变量,他们的地址肯定不同,
      - 对于 i3 == i4
        
        由于前面声明的是 Integer 类型,但是赋值的却是基本类型,中间发生了自动的装箱,调用了 Integer 的 valueOf()方法
        
        下面我们看一下 Integer 的 valueOf 方法的源码:所以当-128<i<127 的时候, valueOf 方法返回的 Integer 对象是一个已经提前创建好的同一个对象
        
        但是如果直接使用 new Integer(66),无论参数值是否在-127<i<128 之间,都是会重新分配内存,新建一个对象
      - 对于 i5 == i6
        
        从上面便可知原因,因为 150 超出了 127,所以自动装箱走的是 new Integer(150),那么就是一个全新的对象了
  - Double 常量池(Double 并没有常量池,这里这么写是为了便于比较)
    - 源码
    - Double.valueOf()的源码:上面的两个 false 很好解释了
    - 那么为什么 Double 没有常量池呢?
      - 是因为在一定范围内,浮点数不像是整型那样,可以穷举出来某一个范围内常用的数据,对于浮点数说,任意范围都是无穷个浮点数
  - Boolean 常量池
    - 源码
- 练习题
  - 题目
  - 前提
    - 当 "=="运算符的两个操作数都是包装器类型的引用，则是比较指向的是否是同一个对象，而如果其中有一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动拆箱的过程）
  - 解答
    - 第一个和第二个输出结果没有什么疑问。第三句由于 a+b 包含了算术运算，因此会触发自动拆箱过程（会调用 intValue 方法），因此它们比较的是数值是否相等。而对于 c.equals(a+b)会先触发自动拆箱过程，再触发自动装箱过程，也就是说 a+b，会先各自调用 intValue 方法，得到了加法运算后的数值之后，便调用 Integer.valueOf 方法，再进行 equals 比较。同理对于后面的也是这样，不过要注意倒数第二个和最后一个输出的结果（如果数值是 int 类型的，装箱过程调用的是 Integer.valueOf；如果是 long 类型的，装箱调用的 Long.valueOf 方法,(a+h)是 long+int,结果会被自动封装成 long 类型,所以装箱也是 long 类型）。
1. 方法区的使用举例
- 1. 源代码
- 1. 运行时数据区
1. 方法区的演进细节
- 前提
  - 1.首先明确:只有 Hotspot オ有永久代,BEA JRockit、IBM J9 等来说,是不存在永久代的概念的。原则上如何实现方法区属于虚拟机实现细节,不受《]ava 虚拟机规范》管束,并不要求统一
- Hotspot 中方法区的变化
  - jdk6:运行时常量池包含字符串常量池和静态变量都位于永久代
  - jdk7:字符串常量池 StringTable(堆)从运行时常量池分开(永久代),静态变量也拿到了堆中
  - jdk8:字符串常量池 StringTable(堆)从运行时常量池分开(永久代),静态变量也拿到了堆中,而且元空间脱离 jvm 内存控制
  - 提出的问题
    - 永久代为什么要被元空间替换?
      - 因为设置永久代的大小是很困难的.如果永久代设置的空间过小,在动态类加载过多的时候,会频繁导致 FullGc 和 OOM,如果永久代设置的空间过大,又会造成浪费,内存都被 jvm 分走了(永久代内存是占用 jvm 的内存分配,给永久代分配过大的内存,即使没有加载过多的类,也无法把空间腾出来给别的程序使用),但是元空间的内存是独立于 jvm 的,直接位于内存的,所以元空间不容易发生 FullGC 也不容易让占据过大的空余内存,导致别的程序无法使用
      - 对于永久代的调优比较困难
    - StringTable 为什么要调整存储位置?
      - jdk7 中将 Stringtable 放到了堆空间中。因为永久代的回收效率很低,在 ful1gc 的时候オ会触发。而 fu11gc 是老年代的空间不足、永久代不足时才会触发这就导致 string Tablel 回收效率不高。而我们开发中会有大量的字符串被创建,回收效率低,导致永久代内存不足。放到堆(新生代,老年代)里,能及时回收内存。
    - 静态变量放在哪里
      - 从上图我们可以看到,静态变量在 jdk6 的时候位于方法区(永久代)中,从 jdk7 以后静态变量位于堆中.但是通过我们做实验可知,静态变量无论 jdk6,7,8 都是存放在堆中的,这岂不是和图片矛盾了?
        
        其实不然,如图所示,之前图片强调的是引用对象本身的变量的存放位置,而对象本身无论 jdk 版本 6,7,8 都是位于堆中
        
        事实是
        new 出来的对象都是放在堆中的,但是引用 new 出来的对象的变量放在哪里呢?对于静态变量存放放在堆中,对于实例变量跟随类的实例对象保存在堆中,而方法中的局部变量保存在方法栈中
1. 方法区的垃圾回收
- 前提
  - 有些人认为方法区如 Hotspot 虚拟机中的元空间或者永久代)是没有垃圾收集行为的,其实不然。《Java 虚拟机规范》对方法区的约東是非常宽松的,提到过可以不要求虚拟机在方法区中实现垃圾收集。事实上也确实有未实现或未能完整实现方法区类型卸载的收集器存在 (如 JDK11 时期的 2GC 收集器就不支持类卸载)
- 方法区 GC 的难点(费力不讨好)
  - 一般来说这个区域的回收效果比较难令人满意,尤其是类型的卸载,条件相当苛刻。但是这部分区域的回收有时又确实是必要的。以前 sun 公司的 Bug 列表中,曾出现过的若干个严重的 Bug 就是由于低版本的 Hotspot 虚拟机对此区域未完全回收而导致内存泄漏。
- 方法区的垃圾收集主要回收两部分内容:
  - 方法区中运行时常量池中废弃的常量(简单)
    - 运行时常量池包含两大类常量
      - 字面量:字面量比较接近]ava 语言层次的常量概念,如文本字符串、被声明为 final 的常量值等。
      - 符号引用
        
        类和接口的全限定名
        
        字段的名称和描述符
        
        方法的名称和描述符
    - 针对运行时常量池的回收策略
      - 只要常量池中的常量没有被任何地方引用,就可以被回收。(回收废弃常量与回收]ava 堆中的对象非常类似。)
  - 方法区中不再使用的类型(费力不讨好)
    - 对于可以回收的类型,需要同时满足以下三个及其苛刻条件(即使全部满足条件,也只是允许回收,是否回收还需要看 jvm 相关参数的设置)
      - 该类所有的实例都已经被回收,也就是 java 堆中不存在该类及其任何派生子类的实例。
      - 加载该类的类加载器已经被回收,这个条件除非是经过精心设计的可替换类加载器的场景,OSGi、jSP 的重加载等,否则通常是很难达成的。
      - 该类对应的 java.1ang.C1ass 对象没有在任何地方被引用,无法在任何地方通过反射访问该类的方法
    - 既然费力不讨好,那么什么场景会使用到方法区的类型回收呢?
      - 在大量使用反射、动态代理、CGLIB 等字节码框架,动态生成 JSP 以及 OSGi 这类频繁自定义类加载器的场景中,通常都需要 Java 虚拟机具各类型卸载的能力,以保证不会对方法区造成过大的内存压力
1. 总结

对象的实例化内存布局与访问定位

引入

在前面的运行时数据区讲了虚拟机栈,堆,方法区,我们 new 一个对象,该对象放在堆中,该对象对应的类信息放在方法区中.如果一个方法中的局部变量,存放栈中,那我们在 new 一个对象的时候是如何把三个内存空间联系到一起的

1. 对象的实例化

创建对象的方式
- new
  - 最常见的方式 new()
  - 变形 1:单例模式的 Xo 的静态方法
  - 变形 2: Xxxbuilder/ Xooxfactoryf 的静态方法
- Class 的 newInstance():反射的方式,只能调用空参的构造器,权限必须是 public,(jdk9 及其以后该方法被标注为过时)
- Constructors 的 newInstance(Xxx):反射的方式,可以用空参、带参的构适,权限没有要求(jdk9 及其以后推荐的反射用法,代替上面的落后方法)
- 使用 clone():不用任何构造器,当前类需要实现 Cloneable:接口,实现 cone()
- 使用反序列化:从文件中、从网络中获取一个对象的二进制流
- 第三方库 Obienesis
创建对象的步骤
- 从字节码角度分析
  - 源码
  - 字节码:new 指令做的是检查是否加载 java.lang.object 的 class 文件,在方法区加仔该类后并在堆空间开辟空间存放对象,对象的大小就是成员变量的所占据的大小的总和 int.char shortbyte boolea 或者引用类型都是占据四个字节 long.double 八个字节并且这个 new 指令还会进行对变量默认的赋值,boolea 赋值为 false,int 赋值为 0
- 从代码的执行步骤分析
  - 1. 判断对象对应的类是否加载,链接,初始化
    - 虚拟机遇到一条 new #x 指令,首先去检查这个指令的参数能否在 Metaspace 的常量池中定位到该类类的符号引用,并且检查这个符号引用代表的类是否已经被加载、解析和初始化。(即判断类元信息是否存在)。
      - 如果没有,那么在双亲委派模式下,使用当前类加载器以 C1 assloader+ 包名 + 类名为 Key 进行查找对应的,c1ass 文件。
        
        如果找到,则进行类加载,并生成对应的 c1ass 类对象
        
        如果没有找到文件,则抛出 Classnotfoundexception 异常,
      - 如果有,直接下一步
  - 1. 为对象分配内存(new type())
    - 1. 首先计算对象占用空间大小(实例对象的成员变量 boolean,byte,char,short,int,引用类型和 float 都占 4 个字节,double 和 long 都占据 8 个字节)
    - 1. 接着在堆中划分一块内存给新对象(new type() 的 new)
      - 如果此时堆内存工整,使用 指针碰撞 分配内存
        
        如果内存是规整的,那么虚拟机将采用的是指针碰撞法( Bump The Pointer)来为对象分配内存。意思是所有用过的内存在一边,空闲的内存在另外一边,中间放着一个指针作为分界点的指示器,分配内存就仅仅是把指针向空闲那边挪动一段与对象大小相等的距离罢了。如果垃圾收集器选择的是 Serial(串行)、 Pardew(并行)这种基于压缩算法的,虚拟机采用这种分配方式。一般使用带有 compact(整理)过程的收集器时,使用指针碰撞。
      - 如果内存不规整,虚拟机需要维护一个列表,使用空闲列表分配(类似 os 中 FAT)
        
        如果内存不是规整的,已使用的内存和未使用的内存相互交错,那么虚拟机将采用的是 空闲列表 法来为对象分配内存。意思是虚拟机维护了一个列表,记录上哪些内存块是可用的,再分配的时候从列表中找到一块足够大的空间划分给对象实例,并更新列表上的内容。这种分配方式成为“空闲列表( Free List)”。
      - 说明:选择哪种分配方式由 Java 堆是否规整決定,而]ava 堆是否规整又由所采用的垃圾收集
        器是否带有压缩整理功能决定。
    - 1. 处理并发安全的问题
      - 引入
        
        如何给对象在堆中开辟内存搞定了,但是我们知道创建对象是一个非常频繁的工作,如果多个线程同时访问堆中的同一快内存,会发生线程的安全问题
      - 解决方案
        
        采用 CAS(Compare and Swap)失败重试、区城加锁,保证更新的原子性(详情自己百度)
        
        TLAB 把内存分配的动作按照线程划分在不同的空间之中进行,即每个线程在 Java 堆中预先分配一小块内存,称为本地线程分配缓冲区,(TLAB, Thread Loca1 A1location Buffer)
        
        通过-XX:+/- USETLAB 参数来开启/关闭(jdk8 默认开启)
    - 1. 初始化分配到的空间
      - 对象内存分配结束,虚拟机将分配到的内存空间都初始化为零值(不包括对象头)。这一步保证了对象的实例字段在 java 代码中可以不用赋初始值就可以直接使用,程序能访问到这些字段的数据类型所对应的默认值
        
        补充:给对象的属性赋值的操作顺序
        
        属性的默认初始化
        
        显式初始化/代码块初始化
        
        构造器中初始化
    - 1. 设置对象的对象头
      - 将对象的所属类(即类的元数据信息)、对象的 Hashcode 和对象的 GC 信息、锁信息.等数据存储在对象的对象头中。这个过程的具体设置方式取决于 JVM 实现。(下节细讲)
    - 1. 执行方法进行初始化(new type() 的 type())
      - 方法是编译器的根据源代码生成的, 方法自动收集源码中的 显式初始化/代码块初始化 和 构造器中初始化 合并而来,这跟自动收集类成员的显式初始化和静态代码块的初始化是一样的

2. 对象的内存布局

包含内容
- 对象头(Header)
  - 运行时元数据
    - 对象的地址
    - GC 分代年龄 age
    - 状态标志
    - 线程持有的锁
    - 偏向线程 ID
    - 偏向时间戬
  - 类型指针
    - 指向类元数据 InstanceClass,确定该对象所属的类型
  - 说明:如果是数组,还需记录数组的长度
- 实例数据(Instance Data)
  - 说明
    - 他是对象真正存储的有效信息,包括程序代码中定义的各种类型的字段(包括从父延承下来的和本身用有的字)
  - 规则
    - 父类中定义的变量会出现在子类之前
    - 相同宽度的字段总是被分配在一起
      - 为了满足内存对齐填充,可以在一个存储周期取出来数据,而且不会造成内存的过多浪费
    - 如果 Compactfields 参数为 true(默认为 true):子类的宿量可能括入到父关变量的空隙
- 对齐填充
  - 为了增加读取数据的性能,如果不对齐的话,读控制较为复杂,可能读取一个子长的单位还需要两次读取内存的周期
案例
- 源码
- 内存分析

3. 对象的访问定位

JVM 是如何通过栈帧中的对象引用访问到其内部的对象实例的呢 ?如图所示
对象的访问方式主要是两种
- 句柄访问
  - 图示
  - 好处
    - reference 中存储稳定柄地址,对象被移动(垃圾收集时移动对象很普遍)时,只会改变句柄中实例数据指针即可, reference 本身不需要被修改
  - 不足
    - 多了一层索引,导致效率降低
    - 还要额外空间来管理句柄池
- 直接指针
  - 图示
  - 好处
    - 访问效率高
  - 不足
    - 堆中对象的地址发生改变,栈中的变量的值的就需要改变

4. 直接内存

引入
- 因为 jdk8 方法区的实现是叫做元空间,元空间使用的不是 jvm 进程的内存,而是本地直接内存
概述
- 不是虚拟机运行时数据区的一部分,也不是《Java 虚拟机规范》中定义的内存区域。
- 直接内存是在 Java 堆外的、直接向系统申请的内存区间。
- 来源于 NIO,通过存在堆中的 Directbytebuffer 操作 Native l 内存
使用 NIO 有什么好处(说实话,这解释爷没有看懂)
直接内存的特点
- 也可能导致 Outofmemoryerror: Direct buffer memor
- 由于直接内存在 Java 堆外,因此它的大小不会直接受限于-Xmx 指定的最大堆大小,但是系统内存是有限的,Java 堆和直接内存的总和依然受限于操作系统能给出的最大内存
- 分配/回收的成本高(因为方法区的内存回收条件太苛刻,方法区在 jdk8 以后被称作元空间,位置也移动到了直接内存中)
- 不受 jvm 的内存回收管理
- 如果不指定,默认与堆的最大值-Xmx 参数值一致
- 直接内存大小可以通过 MaxdirectmemorySize 设置

5. 执行引擎

1. 执行引擎的概述

执行引擎是]ava 虚拟机核心的组成部分之
“虚拟机”是一个相对于“物理机”的概念,这两种机器都有代码执行能力,其区别是物理机的执行引擎是直接建立在处理器、缓存、指令集和操作系统层面上的,而虚拟机的执行引擎则是由软件自行实现的,因此可以不受物理条件制约地定制指令集与执行引繁的结构体系,能够执行那些不被硬件直接支持的指令集格式
JVM 的主要任务是负责装载字节码到其内部,但字节码并不能够直接运行在操作系统之上,因为字节码指令并非等价于本地机器指令,它内部包含的仅仅只是一些能够被 JVM 所识别的字节码指令、符号表,以及其他辅助信息。
那么,如果想要让一个 Java 程序运行起来,执行引擎( Execution Engine)的任务就是将字节码指令解释/编译为对应平台上的本地机器指令オ可以(这里的编译指的是后端编译器)。简单来说,JVM 中的执行引繁充当了将高级语言翻译为机器语言的译者。
- 前端编译:源码->.class 文件
- 后端编译:.class 文件-> 机器指令
执行引擎的工作过程
- 1)执行引在执行的过程中究竟需要执行什么样的字节码指令完全依赖于 PC 寄存器。
- 2)每当执行完一项指令操作后 PC 寄存器就会更新下一条需要被执行的指令地址
- 3)当然方法在执行的过程中,执行引有可能会通过存储在局部变量表中的对象引用准确定位到存储在 Java 堆区中的对象实例信息,以及通过对象头中的元数据指针定位到目标对象的类型信息。

2. java 代码编译和执行过程

javac 前端编译器(其实 javac 跟 jvm 没有什么关系)
编译器和解释器(跟 jvm 有关)
什么是解释器?
- 解释器:当 Java 虚拟机启动时会根据预定义的规范对字节码采用逐行解释的方式执行,将每条字节码文件中的内容“翻译”为对应平台的本地机器指令执行
什么是 JIT 编译器
- JIT( Just In Time Compiler)编译器:就是虚拟机将源代码直接编译成和本地机器平台相关的机器语言。然后编译后的代码缓存在方法区中的 JIT 代码缓冲
问题:为什么说 Java 是半编译半解释语言?
- JDK1.0 时代,将]ava 语言定位为“解释执行”还是比较准确的。再后来, ]ava 也发展出可以直接生成本地代码的编译器。现在 JVM 在执行]ava 代码的时候,通常都会将解释执行与编译执行二者结合起来进行。

3. 机器码,指令,汇编语言

机器码
- 0010101010
机器指令
- mov
指令集
- 机器指令的集合
汇编语言
- 接近自然语言
高级语言
- 更接近自然语言
java 采用字节码的好处是什么?
- 字节码是一种中间状态(中间码)的二进制代码(文件),它比机器码更抽象,需要直译器转译后才能成为机器码
- 它不面向任何特定的处理器，只面向不同的平台的虚拟机。编译器将源码编译成字节码，特定平台上的虚拟机器将字节码转译为可以直接执行的指令

4. 解释器

引入
- JVM 设计者们的初衷仅仅只是单纯地为了满足 Java 程序实现跨平台特性,因此避免采用静态编译的方式直接生成本地机器指令,从而诞生了实现解释器在运行时采用逐行解释字节码执行程序的想法。
解释器的工作内容
- 1. 将字节码中文件中的内容“翻译”为对应平台的本地机器指令执行
- 1. 当一条字节码指令被解释执行完成后,接着再根据 PC 寄存器中记录的下一条需要被执行的字节码指令执行解释操作。
解释器的分类
- 古老的字节码解释器(基本没有使用了)
  - 字节码解释器在执行时通过纯软件代码模拟字节码的执行,效率非常低下
- 模板解释器
  - 而模板解释器将每一条字节码和一个模板函数相关联(模板就是这个 jvm 指令的提前编译的版本),模板函数中直接产生这条字节码执行时的机器码,从而很大程度上提高了解释器的性能
现状
- 解释器设计比较简单,很多语言都支持解释器执行,java,python,perl,ruby,但是解释器的执行效率很低
- 为了解决这个问题,JVM 平台支持一种叫作即时编译的技术。即时编译的目的是避免函数被解释执行,而是将整个函数体编译成为机器码,每次函数执行时,只执行编译后的机器码即可,这种方式可以使执行效率大幅度提升。

5. JIT(Just In Time Compiler) 编译器

前提
- Hotspot VM 是目前市面上高性能虚拟机的代表作之一。它采用解释器与即时编译器并存的架构。在 Java 虚拟机运行时,解释器和即时编译器能够相互协作,各自取长补短,尽力去选择最合适的方式来权衡编译本地代码的时间和直接解释执行代码的时间。(Jrockit 只有编译器,没有解释器)
- 在今天,Java 程序的运行性能早已脱胎换骨,已经达到了可以和 c/C++ 程序一较高下的地步。
既然 JIT 编译器那么牛逼,干嘛还要用性能缓慢的解释器呢?
- 1. 当程序启动后,解释器可以马上发挥作用,省去编译的时间,立即执行。
- 1. 编译器要想发挥作用,把代码编译成本地代码,需要一定的执行时间。但编译为本地代码后,执行效率高。但是明显存在一些启动延迟
- 1. 当 Java 虚拟器启动时,解释器可以首先发挥作用,而不必等待即时编译器全部编译完成后再执行,这样可以省去许多不必要的编译时间。随着时间的推移,编译器发挥作用,把越来越多的代码编译成本地代码,获得更高的执行效率。
- 1. 解释执行在编译器进行激进优化不成立的时候,作为编译器的“逃生门”。
编译器
- 分类
  - 前端编译器:把 .java 代码转变成.class 文件
    - sun 公司的 javac
    - eclipse 的 ECJ
  - 后端运行期编译器:把字节码转为机器码的过程
    - hotspot vm 中的 c1,c2
  - 静态提前编译器:直接把.java 文件编译成本地机器代码的过程
    - GNU compile for java
    - Excelsior jet
热点代码及探测方式
- 是否需要启动 JIT 编译器将字节码直接编译为对应平台的本地机器指令, 则需要根据代码被调用执行的频率而定。关于那些需要被编译为本地代码的字节码,也被称之为“热点代码”,JIT 编译器在运行时会针对那些频繁被调用的“热点代码”做出深度优化,将其直接编译为对应平台的本地机器指令,以此提升 Java 程序的执行性能。
- 热点代码
  - 一个被多次调用的方法,或者是一个方法体内部循环次数较多的循环体都可以被称之为“热点代码”,因此都可以通过 JIT 编译器编译为本地机器指令。由于这种编译方式发生在方法的执行过程中,因此也被称之为栈上替换(因为方法都是压如虚拟机栈中运行),或简称为 OSR( On StackReplacement)编译。
  - 那么提出问题
    - 1. 调用多少次才被称为热点代码?
    - 1. 通过什么来计算方法的调用次数?
  - 解决问题
    - 热点探测解决上述两个问题
- 热点探测
  - 目前 Hotspot VM 所采用的热点採测方式是基于计数器的热点探测。
  - 采用基于计数器的热点探测, Hotspot VM 将会为每一个方法都建立 2 个不同类型的计数器,分别为方法调用计数器( Invocation Counter)和回边计数器(BackEdge Counter)。
    - 方法调用计数器:用于统计方法的调用次数
    - 回边计数器:则用于统计循环体执行的循环次数
  - 方法调用计数器
    - 这个计数器就用于统计方法被调用的次数,它的默认阈值在 C1ient 模式下是 1500 次,在 Server 模式下是 10000 次。超过这个阈值,就会触发 JIT 编译。(这个阈值可以通过虚拟机参数 -XX: Comp11 ethresho1d 来人为设定。)
    - 工作流程
      - 当一个方法被调用时,会先检査该方法是否存在被 JIT 编译过的版本,如果存在,则优先使用编译后的本地代码来执行。如果不存在已被编译过的版本,则将此方法的调用计数器值加 1,然后判断 方法调用计数器 与 回边计数器 值之和是否超过方法调用计数器的阈值。如果已超过阈值,那么将会向即时编译器提交一个该方法的代码编译请求。
    - 存在问题和解决方案
      - 如果不做任何设置,方法调用计数器统计的并不是方法被调用的绝对次数,而是一个相对的执行频率,即一段时间之内方法被调用的次数。当超过一定的时间限度,如果方法的调用次数仍然不足以让它提交给即时编译器编译,那这个方法的调用计数器就会被减少一半,这个过程称为方法调用计数器热度的衰减( Counter Decay),而这段时间就称为此方法统计的半衰周期( Counter Half Life Time),否则只统计方法被调用的绝对次数,只要时间够久,早晚会达到阈值,不符合我们的期望
      - 参数设置
        
        进行热度衰减的动作是在虚拟机进行垃圾收集时顺便进行的,可以使用虚拟机参数 -XX:- UseCounterDecay 来关闭热度衰减,让方法计数器统计方法调用的绝对次数,这样,只要系统运行时间足够长,绝大部分方法都会被编译成本地代码。
        
        另外,可以使用 -XX: CounterHa1lifetime 参数设置半衰周期的时间,单位是秒。
  - 回边计数器
    - 它的作用是统计一个方法中循环体代码执行的次数,在字节码中遇到控制流向后跳转的指令称为“回边”( Back Edge)。显然,建立回边计数器统计的目的就是为了触发热点代码的编译。
Hotspot VM 设置程序运行的方式
- -Xmixed(默认的):采用解释器 + 即时编译器的混合模式共同执行程序。
- -Xint:完全采用解释器模式执行程序
- -Xcomp:完全采用即时编译器模式执行程序。如果即时编译出现问题,解释器会介入执行。
Hotspot VM 中 JIT 的分类
- 在 Hotspot VM 中内嵌有两个 JIT 编译器,分别为 Client Compiler 和 ServerCompiler,但大多数情況下我们简称为 C1 编译器和 C2 编译器。开发人员可以通过如下命令显式指定 Java 虚拟机在运行时到底使用哪一种即时编译器
  - -c1ient:指定 Java 虚拟机运行在 C1ient 模式下,并使用 C1 编译器,C1 编译器会对字节码进行简单和可靠的优化,耗时短。以达到更快的编译速度。
  - -server:指定 Java 虚拟机运行在 Servert 模式下,并使用 C2 编译器,C2 进行耗时较长的优化,以及激进优化。但优化的代码执行效率更高。
- C1 和 C2 编译器不同的优化策略
  - 在不同的编译器上有不同的优化策略,C1 编译器上主要有方法内联,去虚拟化、冗余消除。
    - 方法内联:将引用的函数代码编译到引用点处,这样可以减少栈帧的生成,减少参数传递以及跳转过程
    - 去虚拟化:对唯一的实现类进行内联
    - 冗余消除:在运行期间把一些不会执行的代码折叠掉
  - C2 的优化主要是在全局层面,逃逸分析是优化的基础。基于逃逸分析在 C2 上有如下几种优化:
    - 标量替换:用标量值代替聚合对象的属性值
    - 栈上分配:对于未逃逸的对象分配对象在栈而不是堆
    - 同步消除:清除同步操作,通常指 synchronized
    - 本质上就是 逃逸分析 的内容
- 实际上,C1 和 C2 编译器是相互合作完成编译的
总结
- 一般来讲,J 编译出来的机器码性能比解释器高。
- C2 编译器启动时长比 C1 编译器慢,系统稳定执行以后,C2 编译器执行速度远远快于 1 编译器。
展望
- 自 JDK10 起, Hotspot 又加入一个全新的即时编译器:Graa 编译器,编译效果短短几年时间就追评了 C2 编译器。未来可期。

6. StringTable

1. String 的基本特性

String 是一个类
string:字符串,使用一对""引起来表示
- String str="hello";//类似与基本数据类型的定义方式,但是本质就是一个类,只不过编译器做了特殊的优化
- String str=new String("hello");//类的方式
string 类是声明为 final 的,不可被继承
string 实现了 Serializable 接口:表示字符串是支持序列化的,表示 String 类可以直接进行跨进程传输
实现了 Comparable 接口:表示 string 可以比较大小
string 在 jdk8 及以前内部定义了 final char[] value 用于存储字符串数据。jdk9 时改为 final byte[] value
- 修改动机
  - String 类的 jdk8 及其以前的实现将字符存储在 char 数组中，对于从许多不同应用程序的每个字符数据使用两个字节,(因为一个 char 占据两个字符)，同时字符串是堆使用的主要组成部分，而且，大多数 String 对象只包含 Latin-1 字符(8bit 搞定字符集)。这样的字符只需要一个字节的存储空间，因此这种字符串对象的内部字符数组中有一半的空间没有使用
- 解决方案
  - 我们将 String 类的内部表示形式从 UTF-16 字符数组更改为 字节数组 加上 编码标志 字段。新的 String 类将根据字符串的内容存储编码为 Iso-8859-1/Latin-1（每个字符一个字节）或 Utf-16（每个字符两个字节）编码的字符。同时编码标志将指示所使用的编码
- 结论
  - String 再也不用 char[]来存储啦,改成了 byte[]加上编码标记,节约了一些空间。
  - StringBuilder,StringBuffer 也都针对 String 的改变进行了更改
string 代表不可变的字符序列。简称:不可变性
- 通过字面量的方式(区别于 new)给一个字符串赋值,此时的字符串值声明在字符串常量池中(证明了字符串常量池保存的是字符串的字面量,而不是 String 对象)
  - new 只是开辟了一个内存空间,dup 把刚才的内存空间的地址放入到操作数栈顶中,invokespecial 才是调用构造方法,astore 进行存储
  - String s = "23";没有 new String 对象,直接返回字符串常量池的字符串的地址保存到 s 中
  - String s = new String(23);在内存中 new 了一个 String 对象,然后保存该 String 对象地址到 s 中
- 为什么 String 有不可变性?
  - 因为 String 内部使用一个数组来存放的,jdk8 中使用的是 private final char[] value; final 修饰表示是一个常量,一旦被初次赋值后,就不允许再次修改,并且数组一旦确定下来,大小就不允许再被改变了,所以 String 具有不可变性
  - 疑问:既然 String 的不可变性是因为 final 修饰的 char[],那么 char[]在被赋值一次之后就不允许再次被赋值,那么我们通常使用的更改 s 的值是怎么做到的?
    - 场景一
      - String s = "abc";
        s = "def";
      - 分析:从内存上来讲,此时堆中没有 new String()对象,s 中保存的是字符串常量池"abc"和"def"的地址而已,既然没有 String 对象,那么也就没有 final 修饰的 char[]一说,所以 s 的值可以被修改
    - 场景二
      - String s = new String("abc");
        s = "def";
      - 分析:此时堆中的确 new 了一个 String 对象并用 s 指向该 String 对象,那么 s 的 char[]就是 final 的,但是当我们给 s 修改值的时候,直接修改了 s 的地址不再是堆中的 String 对象的地址,而是字符串常量池中的字符串的地址,跟 final 修饰的 char[]没有关系
    - 场景三
      - String s = new String("abc");
        s =new String("def");
      - 分析:这个就没什么好说的了,直接新生成了一个 String 对象,跟原来的 final char[]没有任何关系
  - 总结
    - :综合来看 String 的不可变性跟 final 修饰的 char[]没有关系,因为 final 修饰的数组变量只保证其指向的数组的内存地址不变化,但是不能保证该内存地址上保存的内容不再变化,
    - 所以字符串的不可变性应该是字符串常量池保证的,跟 final 关系不大
- 不可变性的好处
  - 多线程下更安全,高效
- 不可变性的表现
  - 当对字符串重新赋值时,需要重写指定内存区域赋值,不能使用原有的 va1ue 进行赋值。
  - 当对现有的字符串进行连接操作时,也需要重新指定内存区域赋值,不能使用原有的 va1ue 进行赋值
  - 当调用 string 的 replace()方法修改指定字符或字符串时,也需要重新指定内存区域赋值,不能使用原有的 va1ue 进行赋值。
- 面试题
  - 对于题目来说,虚拟机栈中的 str 变量引用了堆中对象的 str 的地址,所以虚拟机栈中的 str 变量间接的指向了运行时常量池中的字符串"good",然后在方法中改变了该字符串的值为"test ok",由于赋值形式采用 str = "testok",所以栈中 str 指向运行时常量池中中的"test ok"字符串的地址,但是堆中的 str 指向依旧不变,所以输出的仍然是"good",如果代码中是 this.str="test ok",那么输出的也是"test ok"
  - 关于 String 不同赋值形式的区别,参考这里
  - 对于 char[] ,由于没有不可变性,传参的时候是引用传递,所以虚拟机栈中的 char 数组 ch 也指向
    char 数组,所以虚拟机栈中改的数据,堆中的变量 ch 也受到了影响
字符串常量池是不会存储相同内容的字符串的
- String 的字符串常量池是一个固定大小的 Hashtab1e(哈希表,这也是为什么 String 不会存储相同的字符串,字符串常量池是一个封装 Hashtable 的 set 集合)
- 数组的默认值大小长度是 1009。如果放进 string Pool 的 string 非常多,就会造成 Hash 冲突严重,从而导致链表会很长,而链表长了后直接会造成的影响就是当调用 string.internl 时性能会大幅下降。
- 使用 -XX: StringTableSize 可设置 stringtable 的长度
  - 在 jdk6 中 stringtable 是默认就是 1009 的长度(不会像是 Map,Set 那样,数组达到了 0,75 后,会自动扩容),所以如果常量池中的字符串过多就会导致效率下降很快。 jdk6 对 Stringtablesizet 设置没有要求
  - 在 jdk7 中, Stringtable 的长度默认值是 60013, jdk7 对 Stringtablesize 设置没有要求
  - Jdk8 开始,Stringtable 的长度默认值是 60013,设置 String'table 的长度的话,1009 是可设置的最小值。

2. String 的内存分配

前提
- 在 Java 语言中有 8 种基本数据类型和一种比较特殊的类型 String。这些类型为了使它们在运行过程中速度更快、更节省内存,都提供了一种常量池的概念。(这里是为了复用的概念,否则需要不断的开辟/销毁空间,并且很多空间存放的都是冗余的数据)
常量池就类似一个 Java 系统级别提供的缓存。8 种基本数据类型的常量池都是系统协调的, string 类型的常量池比较特殊。它的主要使用方法有两种。
- 直接使用双引号声明出来的 string 对象的字面值会直接存储在常量池中
  - String str="hello";
- 如果不是用双引号声明的 string 对象(字符串拼接,new String()),可以使用 string 提供的 intern()方法。这个后面重点谈
字符串常量池分配位置的变更(前面方法区讲过)
- 变更历史
  - Java6 及以前,字符串常量池存放在永久代(方法区)。
  - Java7 中 Oracle 的工程师对字符串池的逻辑做了很大的改变,即将字符串常量池的位置调整到 Java 堆内。
    - 所有的字符串都保存在堆(Heap)中,和其他普通对象一样,这样可以让你在进行调优应用时仅需要调整堆大小就可以了。
    - 字符串常量池概念原本使用得比较多,但是这个改动使得我们有足够的理由让我们重新考虑在 Java7 中使用 string. intern(),(因为堆空间够大,而且垃圾回收效率高,可以往字符串池中塞入很多的字符串)
  - 其他常量池 Java8 元空间(方法区),字符串常量仍然在堆
- 字符串常量池分配位置为什么要调整?
  - 1. 之前位于永久代(方法区)中,但是永久代的空间过小,容易 OOM
  - 1. 永久代的垃圾回收频率太低

3. String 的基本操作

1. Java 语言规范里要求完全相同的字符串字面量,应该包含同样的 Unicode 字符序列,并且必须是指向同一个 String 类实例。
源码
内存图

4. 字符串拼接操作

结论
- 1. 字符串常量与字符串常量使用 + 拼接结果自动放在运行时字符串常量池,原理是编译期优化
  - 编译期优化
    - 第一种方法证明了编译期优化
    - 第二种方法证明了编译期优化
      - ldc:从运行时常量池读取字符串的地址,并保存在操作数栈中
      - astore_x:保存操作数栈顶的数据到局部变量表中索引为 x 的地方
  - 编译期优化案例
- 1. 常量池中不会存在相同内容的常量。
- 3.但是字符串拼接只要 + 两侧有一个是变量,结果就在堆(非字符串常量池)中。变量拼接的原理是 String Builder
  - 变量
    - 由 StrignBuilder.toString() 可知,该方法内部对 StringBuilder 数组 value 的内容拷贝,所以跟字符串常量池不存在什么关系,自然也不会在字符串常量池中创建 StringBulider 对应的字符串字面量
  - final 修饰的 变量(此时应该叫做常量)
    - 案例
      - 字符串拼接操作不一定使用的是 StringBuilder! 如果拼接符号左右两边都是字符串常量"abc"或常量引用 final String str="abc"，则仍然使用编译期优化，即非 StringBuilder 的方式。
      - 针对于 final 修饰类、方法、基本数据类型、引用数据类型的量的结构时，能使用上 final 的时候建议使用上。
  - 练习题
  - 由此引申出一个多次拼接字符串效率的问题
    - 第一种方法
    - 第二种方法
- 4.如果拼接的结果调用 intern()方法,则主动将常量池中还没有的字符串对象放入池中,并返回此对象地址,如果常量池中已经有该字符串常量,则返回这个字符串常量的地址

5. intern()的使用

是一个 native 方法
前提
- 直接使用双引号声明的 String 对象是放入到字符串常量池中的
作用
- 通过使用 字符串对象.intern(),可以把不是使用双引号声明的 String 对象自动放入到字符串常量池中并返回池中的对应字符串的地址:intern() 方法会从字符串常量池中查询当前字符申是否存在(通过 euqals()方法 比较),若不存在,就会将当前字符串放入常池中并返回地址,如果存在,就返回字符常量池中已经存在的字符串对象的地址
  - 通俗的说,两个字符串 s1,s2,其中 s1.equals(s2)为 true(s1,s2 字面量相等,而不论 s1,s2 的声明方式,因为 equals 比较的就是字面量), 那么 s1.intern()==s2.intern()为 true.
何保证变量 s 指向的是字符串常量池中的数据而不是堆中对象自己内部的数据？
- 有两种方式：
  - 方式一： String s = "shkstart";//字面量定义的方式
    - "shkstart"保存在字符串常量池中,然后变量 s 保存的是"shkstart"保存在字符串常量池中的地址
  - 方式二：调用 intern()
    - String s = new String("shkstart").intern();
      - String s = new String("shkstart");
      - String s = new String("shkstart").intern();
    - String s = new StringBuilder("shkstart").toString().intern();
      - 同上
好处
- 通俗点讲, Interned String 就是确保字符串在内存里只有一份拷贝,这样可以节约内存空间,加快字符串操作任务的执行速度。注意,这个值会被存放在字符串内部池( string Intern Poo1)。
问题
- 1. String str = new String("ab"); 会创建几个对象?
  - 两个,堆中的new String()(jvm 的 new 指令 )和 常量池中的 "ab"(jvm 的 ldc 指令)(如果字符串常量池中已经存在"ab",那就只是创建了 new Strign() 一个对象),通过查看编译后的字节码可以看到
    - new:在堆中创建一个 String 对象
    - ldc:从堆中的字符串常量池中获取字符串对象的地址放入到操作数栈中
- 1. String str = new String("a") + new String("b"); 会创建几个对象?
  - 创建的对象(根据字节码分析得到的)
    - 创建的对象
      - 对象 1:new StringBuilder()
      - 对象 2:new String("a")
      - 对象 3:常量池中的"a"
      - 对象 4:new String("b")
      - 对象 5:常量池中的"b"
      - 对象 6:StringBuilder 的 toString()方法中使用了 new String(value,offset,count) 来生成字符串,但是并没有在字符串常量池中新建字符串,因为使用的构造方法不同,而且字节码文件中也没有 ldc 表示从字符串常量池中取数据的字样
    - jvm 指令
      - aload_0:从本地变量表中的 index 为 0 的位置取出变量(该变量中保存的必须是一个地址或者说该变量必须是一个引用)放入到操作数栈中
      - getfield #x:拿到对象中的字段的地址,放到操作数中
- 1. 美团文章
  - 原题 1
    - 总结
      - jdk6:使用 intern() 会在池中创建了一个新的对象"11",并返回池中字符的地址。
      - jdk7:此时池中并没有创建"11",而是在池中创建一个指向堆空间中 new String("11")的地址
      - 这都是因为字符串常量池从方法区移动到了堆中所造成的
  - 原题 2
- 1. 练习
  - 1.
内存效率测试
- 题目
- 运行结果分析
  - 运行结果为 10 秒
  - 运行结果为 1.2 秒
- 分析
  - 对于不使用 intern()方法
    - String.valueOf(data[i % data.length]) 的内部实现是利用 Integer 对象的 toSting()方法,而 Integer 的 toString() 方法内部使用一个 char[] 实现的,并把 new String() 的对象的 value 属性指向了 char[],所以出现了 char[]==String
    - 内存图(类成员是分布在方法区)
  - 对于使用 intern()方法
    - `String.valueOf(data[i % data.length]).intern();把生成的字符串都放到了字符串常量池中,并返回给 arr[i],而内存中没有应用的 newString()和 new char[]都会因为没有引用,而被 gc 回收,减少内存的占用
    - 内存图
- 总结
  - 大的网站平台,需要内存中存储大量的字符串。比如社交网站,很多人都存储:北京市、海淀区等信息。这时候如果字符串都调用 intern()方法,就会明显降低内存的大小。

6. StringTable 的垃圾回收

如上面的 intern()的内存效率测试章节一样,当我们使用 intern()方法的时候存在着内存的回收,原因上面已经讲解的很清楚了

7. G1 的 String 去重操作

引入
- 一个 java 程序中的 String 占据了堆中存活数据的 25%,并且这个 25% 的字符床有很多都是重复的,即为 str1.equals(str2),堆上存在重复的对象必然是一种浪费,因为会使得 GC 更加频繁,影响性能
- 注意这里的 Strnig 去重是去除堆中重复的对象,而不是字符串池中的,因为字符串池本身的字符串就不允许重复
分析
- 堆中的两个 new String()对象存在着重复的情况
实现
- 当垃圾收集器 G!工作的时候,会访问堆上存活的对象。对每一个访问的对象都会检查是否是候选的要去重的 string,对象。(使用一个 hashtable 来记录所有的被 string 对象使用的不重复的 char 数组。当去重的时候,会查这个 hashtable,来看堆上是否已经存在一个一模一样的 char 数组。)
  - 如果是,string 对象会调整 value 引用的数组,释放对原来的数组的引用,最终 char[]会被垃圾收集器回收掉。然后把这个 String 对象的一个引用插入到队列中等待后续的处理。一个去重的线程在后台运行,处理这个队列。处理队列的一个元素意味着从队列删除这个元素,然后尝试去重它引用的 string 对象。
  - 如果査找失败,cha ェ数组会被插入到 hashtable,这样以后的时候就可以共享这个数组了。

JVM GC

如何确定垃圾

引用计数法
- 在 Java 中，引用和对象是有关联的。如果要操作对象则必须用引用进行。因此，很显然一个简单的办法是通过引用计数来判断一个对象是否可以回收。简单说，即一个对象如果没有任何与之关联的引用，即他们的引用计数都不为 0，则说明对象不太可能再被用到，那么这个对象就是可回收对象
- 但是如果出现 A 引用了 B，B 又引用了 A，这时候就算他们都不再使用了，但因为相互引用计算器=1 永远无法被回收。此方法简单，无法解决对象相互循环引用的问题。
可达性分析
- 为了解决引用计数法的循环引用问题， Java 使用了可达性分析的方法。通过一系列的“GC roots” 对象作为起点搜索。如果在“GC roots”和一个对象之间没有可达路径，则称该对象是不可达的。
- 要注意的是，不可达对象不等价于可回收对象，不可达对象变为可回收对象至少要经过两次标记过程。两次标记后仍然是可回收对象，则将面临回收。
- 哪些对象可以作为 GC Roots？
  - 虚拟机栈（栈帧中的局部变量）中引用的对象。
  - 本地方法栈（native）中引用的对象。
  - 方法区中常量引用的对象。
  - 方法区中类静态属性引用的对象。

如何解决垃圾

标记清除算法（ Mark-Sweep）
- 实现
  - 最基础的垃圾回收算法，分为两个阶段，
    - 标注
      - 标记阶段标记出所有需要回收的对象
    - 清除
      - 清除阶段回收被标记的对象所占用的空间
- 特点
  - 从图中我们就可以发现，该算法最大的问题是内存碎片化严重，后续可能发生大对象不能找到可利用空间的问题
复制算法（copying）
- 引入
  - 为了解决 Mark-Sweep 算法内存碎片化的缺陷而被提出的算法。按内存容量将内存划分为等大小的两块。每次只使用其中一块，当这一块内存满后将尚存活的对象复制到另一块上去，把已使用的内存清掉
- 实现
- 特点
  - 这种算法虽然实现简单，内存效率高，不易产生碎片，但是最大的问题是可用内存被压缩到了原本的一半。且存活对象增多的话， Copying 算法的效率会大大降低
标记整理算法(Mark-Compact)
- 引入
  - 结合了以上两个算法，为了避免缺陷而提出。标记阶段和 Mark-Sweep 算法相同，标记后不是清理对象，而是将存活对象移向内存的一端。然后清除端边界外的对象
- 实现
分代收集算法
- 引入
  - 分代收集法是目前大部分 JVM 所采用的方法，其核心思想是根据对象存活的不同生命周期将内存划分为不同的域，一般情况下将 GC 堆划分为老生代(Tenured/Old Generation)和新生代(Young Generation)。老生代的特点是每次垃圾回收时只有少量对象需要被回收，新生代的特点是每次垃圾回收时都有大量垃圾需要被回收，因此可以根据不同区域选择不同的算法
- 新生代与复制算法
  - 目前大部分 JVM 的 GC 对于新生代都采取 Copying 算法，因为新生代中每次垃圾回收都要回收大部分对象，即要复制的操作比较少，但通常并不是按照 1： 1 来划分新生代。一般将新生代划分为一块较大的 Eden 空间和两个较小的 Survivor 空间(From Space, To Space)，每次使用 Eden 空间和其中的一块 Survivor 空间，当进行回收时，将该两块空间中还存活的对象复制到另一块 Survivor 空间中。
  - 减少内存碎片
- 老年代与标记整理算法
  - 老年代因为每次只回收少量对象，因而采用 Mark-Compact 算法
    - 1. JAVA 虚拟机提到过的处于方法区的永生代(Permanet Generation)，它用来存储 class 类，常量，方法描述等。对永生代的回收主要包括废弃常量和无用的类。
    - 1. 对象的内存分配主要在新生代的 Eden Space 和 Survivor Space 的 From Space(Survivor 目前存放对象的那一块)，少数情况会直接分配到老生代。
    - 1. 当新生代的 Eden Space 和 From Space 空间不足时就会发生一次 GC，进行 GC 后， Eden Space 和 From Space 区的存活对象会被挪到 To Space，然后将 Eden Space 和 From Space 进行清理。
    - 1. 如果 To Space 无法足够存储某个对象，则将这个对象存储到老生代。
    - 1. 在进行 GC 后，使用的便是 Eden Space 和 To Space 了，如此反复循环。
    - 1. 当对象在 Survivor 区躲过一次 GC 后，其年龄就会 +1。默认情况下年龄到达 15 的对象会被移到老生代中。
- 总结
  - 在新生代
    - 复制算法每次垃圾收集都能发现大批对象已死, 只有少量存活. 因此选用复制算法, 只需要付出少量存活对象的复制成本就可以完成收集.
  - 在老年代
    - 标记整理算法因为对象存活率高、没有额外空间对它进行分配担保, 就必须采用“标记—清理”或“标记—整理” 算法来进行回收, 不必进行内存复制, 且直接腾出空闲内存

GC 分代收集算法 VS 分区收集算法

分代收集算法
- 当前主流 VM 垃圾收集都采用”分代收集” (Generational Collection)算法, 这种算法会根据对象存活周期的不同将内存划分为几块, 如 JVM 中的新生代、老年代、永久代，这样就可以根据各年代特点分别采用最适当的 GC 算法
  - 在新生代
    - 复制算法每次垃圾收集都能发现大批对象已死, 只有少量存活. 因此选用复制算法, 只需要付出少量存活对象的复制成本就可以完成收集.
  - 在老年代
    - 标记整理算法因为对象存活率高、没有额外空间对它进行分配担保, 就必须采用“标记—清理”或“标记—整理” 算法来进行回收, 不必进行内存复制, 且直接腾出空闲内存
分区收集算法
- 分区算法则将整个堆空间划分为连续的不同小区间, 每个小区间独立使用, 独立回收. 这样做的好处是可以控制一次回收多少个小区间 , 根据目标停顿时间, 每次合理地回收若干个小区间(而不是整个堆), 从而减少一次 GC 所产生的停顿

GC 垃圾收集器

Java 堆内存被划分为新生代和年老代两部分，新生代主要使用复制和标记-清除垃圾回收算法；年老代主要使用标记-整理垃圾回收算法，因此 java 虚拟中针对新生代和年老代分别提供了多种不同的垃圾收集器,JDK1.6 中 Sun HotSpot 虚拟机的垃圾收集器如下
年轻代垃圾回收器
- Serial([ˈ sɪriəl]) 垃圾收集器（单线程、复制算法）
  - Serial（英文连续）是最基本垃圾收集器，使用复制算法，曾经是 JDK1.3.1 之前新生代唯一的垃圾收集器。
  - Serial 是一个单线程的收集器，它不但只会使用一个 CPU 或一条线程去完成垃圾收集工作，并且在进行垃圾收集的同时，必须暂停其他所有的工作线程，直到垃圾收集结束。 S
  - erial 垃圾收集器虽然在收集垃圾过程中需要暂停所有其他的工作线程，但是它简单高效，对于限定单个 CPU 环境来说，没有线程交互的开销，可以获得最高的单线程垃圾收集效率，因此 Serial 垃圾收集器依然是 java 虚拟机运行在 Client 模式下默认的新生代垃圾收集器
- ParNew 垃圾收集器（Serial+ 多线程复制）
  - ParNew 垃圾收集器其实是 Serial 收集器的多线程版本，也使用复制算法，除了使用多线程进行垃圾收集之外，其余的行为和 Serial 收集器完全一样， ParNew 垃圾收集器在垃圾收集过程中同样也要暂停所有其他的工作线程。
  - ParNew 收集器默认开启和 CPU 数目相同的线程数，可以通过-XX:ParallelGCThreads 参数来限制垃圾收集器的线程数。【Parallel：平行的】
  - ParNew 虽然是除了多线程外和 Serial 收集器几乎完全一样，但是 ParNew 垃圾收集器是很多 java 虚拟机运行在 Server 模式下新生代的默认垃圾收集器。
- Parallel Scavenge [ˈ skævɪndʒ] 收集器（多线程复制算法、自适应调节以提高程序吞吐量）
  - Parallel Scavenge 收集器也是一个新生代垃圾收集器，同样使用复制算法，也是一个多线程的垃圾收集器，它重点关注的是程序达到一个可控制的吞吐量，高吞吐量可以最高效率地利用 CPU 时间，尽快地完成程序的运算任务，主要适用于在后台运算而不需要太多交互的任务。自适应调节策略也是 ParallelScavenge 收集器与 ParNew 收集器的一个重要区别。
  - 即吞吐量=运行用户代码时间/(运行用户代码时间 + 垃圾收集时间)
老年代垃圾收集器
- Serial Old 收集器（单线程标记整理算法）
  - Serial Old 是 Serial 垃圾收集器年老代版本，它同样是个单线程的收集器，使用标记-整理算法，这个收集器也主要是运行在 Client 默认的 java 虚拟机默认的年老代垃圾收集器
  - 在 Server 模式下，主要有两个用途：
    - 1. 在 JDK1.5 之前版本中与新生代的 Parallel Scavenge 收集器搭配使用。
    - 1. 作为年老代中使用 CMS 收集器的后备垃圾收集方案。
  - 新生代 Serial 与年老代 Serial Old 搭配垃圾收集过程图
  - 新生代 Parallel Scavenge/ParNew 与年老代 Serial Old 搭配垃圾收集过程图：
- Parallel Old 收集器（多线程标记整理算法）
  - Parallel Old 收集器是 Parallel Scavenge 的年老代版本，使用多线程的标记-整理算法，在 JDK1.6 才开始提供
  - 在 JDK1.6 之前，新生代使用 ParallelScavenge 收集器只能搭配年老代的 Serial Old 收集器，只能保证新生代的吞吐量优先，无法保证整体的吞吐量， Parallel Old 正是为了在年老代同样提供吞吐量优先的垃圾收集器，如果系统对吞吐量要求比较高，可以优先考虑新生代 Parallel Scavenge 和年老代 Parallel Old 收集器的搭配策略
  - 新生代 Parallel Scavenge 和年老代 Parallel Old 收集器搭配运行过程图：
- CMS 收集器（多线程标记清除算法）
  - Concurrent mark sweep(CMS)收集器是一种年老代垃圾收集器，其最主要目标是获取最短垃圾回收停顿时间，和其他年老代使用标记-整理算法不同，它使用多线程的标记-清除算法。最短的垃圾收集停顿时间可以为交互比较高的程序提高用户体验
    - 标记-清除算法会产生内存碎片
  - CMS 工作机制相比其他的垃圾收集器来说更复杂，整个过程分为以下 4 个阶段：
    - 初始标记
      - 只是标记一下 GC Roots 能直接关联的对象，速度很快，仍然需要暂停所有的工作线程。
    - 并发标记
      - 进行 GC Roots 跟踪的过程，和用户线程一起工作，不需要暂停工作线程。
    - 重新标记
      - 为了修正在并发标记期间，因用户程序继续运行而导致标记产生变动的那一部分对象的标记记录，仍然需要暂停所有的工作线程。
    - 并发清除
      - 清除 GC Roots 不可达对象，和用户线程一起工作，不需要暂停工作线程。由于耗时最长的并发标记和并发清除过程中，垃圾收集线程可以和用户现在一起并发工作，所以总体上来看 CMS 收集器的内存回收和用户线程是一起并发地执行
  - CMS 收集器工作过程
- G1 收集器 (分区垃圾处理)
  - Garbage first 垃圾收集器是目前垃圾收集器理论发展的最前沿成果，相比与 CMS 收集器， G1 收集器两个最突出的改进是：
  - 集器两个最突出的改进是：
    - 1. 基于标记-整理算法，不产生内存碎片。
    - 1. 可以非常精确控制停顿时间，在不牺牲吞吐量前提下，实现低停顿垃圾回收
  - G1 收集器避免全区域垃圾收集，它把堆内存划分为大小固定的几个独立区域，并且跟踪这些区域的垃圾收集进度，同时在后台维护一个优先级列表，每次根据所允许的收集时间，优先回收垃圾最多的区域。区域划分和优先级区域回收机制，确保 G1 收集器可以在有限时间获得最高的垃圾收集效率。

JAVA 四中引用类型

强引用
- 在 Java 中最常见的就是强引用，把一个对象赋给一个引用变量，这个引用变量就是一个强引用。当一个对象被强引用变量引用时，它处于可达状态，它是不可能被垃圾回收机制回收的，即使该对象以后永远都不会被用到 JVM 也不会回收。因此强引用是造成 Java 内存泄漏的主要原因之一。
软引用
- 软引用需要用 SoftReference 类来实现，对于只有软引用的对象来说，当系统内存足够时它不会被回收，当系统内存空间不足时它会被回收。软引用通常用在对内存敏感的程序中。
弱引用
- 弱引用需要用 WeakReference 类来实现，它比软引用的生存期更短，对于只有弱引用的对象来说，只要垃圾回收机制一运行，不管 JVM 的内存空间是否足够，总会回收该对象占用的内存
虚引用
- 虚引用需要 PhantomReference 类来实现，它不能单独使用，必须和引用队列联合使用。虚引用的主要作用是跟踪对象被垃圾回收的状态
  - 当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在垃圾回收后，将这个虚引用加入引用队列，在其关联的虚引用出队前，不会彻底销毁该对象。所以可以通过检查引用队列中是否有相应的虚引用来判断对象是否已经被回收了。
  - 使用虚引用的目的就是为了得知对象被 GC 的时机，所以可以利用虚引用来进行销毁前的一些操作，比如说资源释放等。
  - 显式使用虚引用可以阻止对象被清除，只有在程序中显式或者隐式移除这个虚引用时，这个已经执行过 finalize 方法的对象才会被清除。想要显式的移除虚引用的话，只需要将其从引用队列中取出然后扔掉（置为 null）即可。

JVM 参数

JVM 三种类型参数

标配参数
- 比如-version、-help、-showversion 等，几乎不会改变。
X 参数
- 用得不多，比如-Xint，解释执行模式；-Xcomp，编译模式；-Xmixed，开启混合模式（默认）。
XX 参数
- 重要，用于 JVM 调优。

JVM XX 参数

布尔类型
- 公式：-XX:+ 某个属性、-XX:-某个属性，开启或关闭某个功能
- 比如-XX:+PrintGCDetails，开启 GC 详细信息。
KV 键值类型
- 公式：-XX:属性 key=值 value。
- 比如-XX:Metaspace=128m、-XX:MaxTenuringThreshold=15。

JVM Xms/Xmx 参数

-Xms 和-Xmx 十分常见，用于设置初始堆大小和最大堆大小。第一眼看上去，既不像 X 参数，也不像 XX 参数。
实际上-Xms 等价于-XX:InitialHeapSize，-Xmx 等价于-XX:MaxHeapSize。所以-Xms 和-Xmx 属于 XX 参数。

JVM 查看参数

查看参数步骤
- 先用 jps -l 查看 java 进程，得到某个进程号。
- jinfo -flag JVM 参数 pid
查看所有参数的 2 种方法
- 使用 jps -l 配合 jinfo -flags pid 可以查看所有参数。
- 使用 java -XX:+PrintFlagsInitial 效果更好
  - 使用 java -XX:PrintFlagsFinal 可以查看修改后的参数，与上面类似。只是修改过后是:=而不是=

JVM 常用参数

-Xmx/-Xms
- 最大和初始堆大小。最大默认为物理内存的 1/4，初始默认为物理内存的 1/64。
-Xss
- 等价于-XX:ThresholdStackSize。用于设置单个栈的大小，系统默认值是 0，不代表栈大小为 0。而是根据操作系统的不同，有不同的值。比如 64 位的 Linux 系统是 1024K，而 Windows 系统依赖于虚拟内存。
-Xmn
- 新生代大小，一般不调。
-XX:MetaspaceSize
- 设置元空间大小。
-XX:+PrintGCDetails
- 输出 GC 收集信息，包含 GC 和 Full GC 信息。
-XX:SurvivorRatio
- 新生代中，Eden 区和两个 Survivor 区的比例，默认是 8:1:1。通过-XX:SurvivorRatio=4 改成 4:1:1
-XX:NewRatio
- 老生代和新年代的比列，默认是 2，即老年代占 2，新生代占 1。如果改成-XX:NewRatio=4，则老年代占 4，新生代占 1。
-XX:MaxTenuringThreshold
- 新生代设置进入老年代的时间，默认是新生代逃过 15 次 GC 后，进入老年代。如果改成 0，那么对象不会在新生代分配，直接进入老年代。

OutOfMemoryError

java.lang.StackOverflowError

栈溢出，我们有最简单的一个递归调用，就会造成堆栈溢出，也就是深度的方法调用

java.lang.OutOfMemoryError

java.lang.OutOfMemoryError：java heap space
- 创建了很多对象，导致堆空间不够存储
java.lang.OutOfMemoryError：GC overhead limit exceeeded
- GC 回收时间过长时会抛出 OutOfMemoryError，过长的定义是，超过了 98% 的时间用来做 GC，并且回收了不到 2% 的堆内存
- 那就是 GC 清理的这点内存很快会再次被填满，迫使 GC 再次执行，这样就形成了恶性循环，CPU 的使用率一直都是 100%，而 GC 却没有任何成果。
java.lang.OutOfMemoryError：Direct buffer memory
- 在写 NIO 程序的时候，会用到 ByteBuffer 来读取和存入数据。与 Java 堆的数据不一样，ByteBuffer 使用 native 方法，直接在堆外分配内存。当堆外内存（也即本地物理内存）不够时，就会抛出这个异常。
java.lang.OutOfMemoryError：unable to create new native thread
- 在高并发应用场景时，如果创建超过了系统默认的最大线程数，就会抛出该异常。Linux 单个进程默认不能超过 1024 个线程。解决方法要么降低程序线程数，要么修改系统最大线程数 vim /etc/security/limits.d/90-nproc.conf。
java.lang.OutOfMemoryError：Metaspace
- 元空间满了就会抛出这个异常。

‍

posted @ 2025-02-21 12:50 红豆绿豆abc 阅读(76) 评论(0) 收藏举报

刷新页面返回顶部

欢迎来到红豆绿豆部落格

JVM基础知识

JVM学习

jvm

前提

课程章节

jdk 版本

JVM 与 java 体系结构

前言

java 和 JVM 简介

虚拟机和 java 虚拟机

JVM 整体结构

java 代码的执行过程

JVM 的架构模型

JVM 的生命周期

JVM 的发展历程

类加载子系统

类加载器和类的加载过程

类加载器的分类

运行时数据区概述及线程

概述

线程

程序计数器寄存器(PC 寄存器)

虚拟机栈(java 栈)

本地方法栈

堆

方法区

对象的实例化内存布局与访问定位

引入

1. 对象的实例化

2. 对象的内存布局

3. 对象的访问定位

4. 直接内存

5. 执行引擎

1. 执行引擎的概述​

2. java 代码编译和执行过程

3. 机器码,指令,汇编语言

4. 解释器

5. JIT(Just In Time Compiler) 编译器

6. StringTable

1. String 的基本特性

2. String 的内存分配

3. String 的基本操作

4. 字符串拼接操作

5. intern()的使用

6. StringTable 的垃圾回收

7. G1 的 String 去重操作

JVM GC

如何确定垃圾

如何解决垃圾

GC 分代收集算法 VS 分区收集算法

GC 垃圾收集器

JAVA 四中引用类型

JVM 参数

JVM 三种类型参数

JVM XX 参数

JVM Xms/Xmx 参数

JVM 查看参数

JVM 常用参数

OutOfMemoryError

java.lang.StackOverflowError

java.lang.OutOfMemoryError

1. 执行引擎的概述