2020-11-21

第1章：JVM与Java体系结构

01-JVM内存与垃圾回收篇概述

对 Java 程序员来说，Java 虚拟机（JVM ）可以说是既熟悉又神秘，很少有 Java 程序员能够抑制自己探究它的冲动。可惜透彻讲解 JVM 的书籍（尤其是国内出版的）简直少之又少，这里就更不要说能系统讲解 JVM 的视频教程了。尚硅谷的这套 JVM 从入门到精通，绝对可谓是研究 JVM 的程序员及广大 JVM 爱好者的福音。

课程内容分为四个篇章

1. 内存与垃圾回收篇
2. 字节码与类的加载篇
3. 性能监控与调优篇
4. 大厂面试篇

本套视频使用到的软件

https://wws.lanzous.com/b01bi151i

# JDK1.8	目前企业用的比例最高的JDK，本课程基于java8
# JClassLib_windows.zip 	用它读懂字节码文件
# MemoryAnalyzer-1.9.0.20190605-win32.win32.x86_64.zip	内存分析工具
# PXBinaryViewerSetup.exe	读取字节码的软件

使用到的资料

java虚拟机规范可以去官网下载，也可以去买jvm相关的书。

内存与垃圾回收篇目录

02-如何看待Java上层技术与JVM

作为 Java 工程师的你曾被 JVM 伤害过吗?你是否也遇到过这些问题？

• 运行着的线上系统突然卡死，系统无法访问，甚至直接OOM！
• 想解决线上 JVM GC 问题，但却无从下手。
• 新项目上线，对各种 JVM 参数设置一脸茫然，直接默认吧，然后就 JJ了
• 每次面试之前都要重新背一遍 JVM 的一些原理概念性的东西，然而面试官却经常问你在实际项目中如何调优 JVM 参数，如何解决 GC、OOM 等问题，一脸懵逼。

大部分Java开发人员，除了会在项目中使用到java平台相关的高精尖技术，对与Java技术的核心Java虚拟机了解很少

开发人员如何看待上层框架？

一些有一定工作经验的开发人员，打心底觉得SSM，微服务等上层技术才是重点，基础技术并不重要，这其实是一种本末倒置的“病态”。

如果我们把核心类库的API比作数学公式的话，那么Java虚拟机的知识就好比公式的推导过程

计算机系统体系对我们来说越来越远，在不了解底层实现方式的前提下，通过高级语言很容易编程程序代码。但事实上计算机并不认识高级语言

架构师每天都在思考什么？

• 应该如何让我的系统更快？
• 如何避免系统出现瓶颈？

03-为什么要学习JVM

为什么要学习JVM?

• 面试的需要(面试爱问)
• 中高级程序员必备技能
  • 项目的管理，调优的需要
• 追求极客的精神（更高追求）
  • 理解垃圾回收算法，JIT(即时编译),底层原理

Java对比C++

java抛弃了C/C++的两大缺点，Java可以内存动态分配，有垃圾回收技术；

自动分配的内存要想再次使用就需要用到垃圾回收技术

垃圾回收机制为我们打理了很多繁琐的工作，大大提高开发的效率，但是垃圾回收机制不是万能的，

懂得JVM内部的内存结构，工作机制，是设计高扩展性应用和诊断运行时问题的基础，

也是java开发工程师进阶的必备能力。

04-面向人群和课程特点

本课程面向人群

• 拥有一定开发经验的 Java 平台开发人员
• 虚拟机爱好者，JVM 实践者
• 有一定的 Java 编程基础并希望进一步理解 Java 的程序员
• 软件设计师，架构师
• 系统调优人员

先学习怎么使用，再去了解原理是什么！别一开始就打消了积极性。

调优在课程第三篇会讲，会用到很多具体的监控工具

调优：代码层面、内存层面

代码层面i++，++i有何区别？

我们需要把代码编译成字节码文件，然后再反编译才能解释区别。

课程特点

1. 讲理论的时间>讲代码的时间
2. 通俗易懂说人话
3. 图解

05-官方规范下载与参考书目

Java语言规范和JVM规范，推荐看8或者11，可以去官网下载https://docs.oracle.com/javase/specs/index.html

英语薄弱者请无视。

不推荐买Java虚拟机规范这本书，规范未必能看得懂。推荐买深入理解Java虚拟机，我们要买的是规范的解读。

JVM规范是Oracle公司发布的标准，随着JDK的不断更新，JVM规范也在不断迭代。规范是虚的，属于天上飞的理念，落地的实现是具体不同版本的Java虚拟机。JVM规范有很多版本，java虚拟机也有很多版本，我们要学的是官方正统的HotSpot虚拟机.

06-跨平台的语言Java和跨语言的平台JVM

跨平台的语言Java

世界上没有最好的语言，只有最适用于具体应用场景的编程语言。Java目前仍是世界上最流行的编程语言。

Java 不再是简简单单的一门计算机语言了，它更是一个平台，一种文化，一个社区，形成了庞大的生态。

java的特点之一：跨平台

Java的官网介绍

The Java Virtual Machine is the cornerstone of the Java platform. It is thecomponent of the technology responsible for its hardware- and operating system-independence, the small size of its compiled code, and its ability to protect usersfrom malicious programs…
Java虚拟机是Java平台的基石。它是该技术的组成部分，负责其硬件和操作系统的独立性，以及负责编译后代码的小尺寸，它具有保护用户免受恶意程序攻击的能力…

跨语言的平台JVM

Java虚拟机根本不关心运行在其内部的程序到底是使用哪种语言编写的，它只关心字节码文件。只要编译后的字节码文件符合Java虚拟机的规范，它就是一个有效的字节码文件，就能被Java虚拟机识别并装载运行。

Java语言不是最强大的语言，但是jvm是最强大的虚拟机。

07-字节码与多语言混合编程

字节码

• 我们平时说的java字节码， 指的是用java语言编译成的字节码。准确的说任何能在jvm平台上执行的字节码格式都是一样的。所以应该统称为:jvm字节码。
• 不同的编译器，可以编译出相同的字节码文件，字节码文件也可以在不同的JVM上运行。
• Java虚拟机与Java 语言并没有必然的联系，它只与特定的二进制文件格式一Class文件格式所关联， Class文件中包含了Java 虚拟机指令集(或者称为字节码、Bytecodes) 和符号表，还有一些其他辅助信息。

信息产业三大难题：CPU，操作系统，编译器

多语言混合编程

Java平台上的多语言混合编程正成为主流，通过特定领域的语言去解决特定领域的问题是当前软件开发应对日趋复杂的项目需求的一个方向。

试想一下，在一个项目之中，并行处理用clojure语言编写，展示层使用JRuby/Rails,，中间层则是Java，每个应用层都将使用不同的编程语言来完成，而且，接口对每一层的开发者都是透明的，各种语言之间的交互不存在任何困难，就像使用自己语言的原生API一样方便，因为它们最终都运行在一个虚拟机之上。

对这些运行于Java虚拟机之上、Java之外的语言，来自系统级的、底层的支持正在迅速增强，以JSR-292为核心的一 系列项目和功能改进(如DaVinci Machine项目、 Nashorn引擎、InvokeDynamic指令、java. lang. invoke包等)，推动Java虚拟机从Java语言的虚拟机向多语言虚拟机的方向发展。

如何真正搞懂jvm?

Java虚拟机非常复杂，要想真正理解它的工作原理，最好的方式就是实践！自己动手编写一个jvm!

08-Java及JVM历史上的重大事件

1990年，在Sun公司中，由JamesGosling领导的小组Green Team,开发出的新的程序语言，命名为Oak,后期命名为Java

1995年，Sun正式发布Java和HotJava产品，Java 首次公开亮相。

1996年1月23日Sun公司发布了JDK 1.0。

1998年，JDK 1.2版本发布。同时，Sun发布了jsp/Servlet、EJB规范，以及将Java分成了J2EE、 J2SE和J2ME。这表明 了Java开始向企业、 桌面应用和移动设备应用三大领域挺进。

2000年，JDK 1.3发布,Java HotSpot Virtual Machine正式发布，成为Java的默认虚拟机。

2002年，JDK 1.4发布，古老的Classic虚拟机退出历史舞台。

2003年年底，Java平台的Scala正式发布，同年Groovy也加入了Java阵营。

2004年，JDK 1.5发布。同时JDK 1. 5改名为JavaSE 5.0。

2006年，JDK 6发布。同年，Java开源并建立了OpenJDK。 顺理成章，Hotspot虚拟机也成为了OpenJDK中 的默认虚拟机。

2007年，Java平台迎来了新伙伴Clojure。

2008年，Oracle 收购了BEA, 得到了JRockit 虚拟机。

2009年，Twitter宣布把后台大部分程序从Ruby迁移到Scala，这是Java平台的又一次大规模应用。

2010年，Oracle收购了Sun,获得Java商标和最具价值的HotSpot虚拟机。此时，Oracle拥有市场占用率最高的两款虚拟机Hotspot和JRockit，并计划在术来对它们进行整合: HotRockit。 JCP组织管理Java语言

2011年，JDK7发布。在JDK 1.7u4中，正式启用了新的垃圾回收器G1。

2017年，JDK9发布。将G1设置为默认GC，替代CMS。同年，IBM的J9开源，形成了现在的Open J9社区

2018年，Android的Java侵权案判决，Google赔偿Oracle计88亿美元

同年，Oracle宣告JavaEE成为历史名词，JDBC、 JMS、Servlet赠予Eclipse基金会

同年，JDK11发布，LTS版本的JDK,发布革命性的ZGC,调整JDK授权许可

2019年，JDK12发布，加入RedHat领导开发的Shenandoah GC

三大商用虚拟机:sun系列的HotSpot、JRockit虚拟机、IBM J9虚拟机

jdk版本

Open JDK和Oracle JDK

在JDK11之前，OracleJDK中还会存在一些openJDK中没有的、闭源的功能。但在JDK11中，除了协议不同之外，

我们可以认为open JDK和Oracle JDK代码实质上已经完全一致的程度 。

09-虚拟机与Java虚拟机介绍

• 所谓虚拟机(Virtual Machine)， 就是一台虚拟的计算机、它是一款软件，用来执行一系列虚拟计算机指令。大体上，虚拟机可以分为系统虚拟机和程序虛拟机。
  1. 大名鼎鼎的Visual Box, VMware就属于系统虚拟机，它们完全是对物理计算机的仿真，提供了一个可运行完整操作系统的软件平台。
  2. 程序虚拟机的典型代表就是Java虚拟机,它专门为执行单个计算机程序而设计，在Java虚拟机中执行的指令我们称为Java字节码指令。
• 无论是系统虚拟机还是程序虚拟机，在上面运行的软件都被限制于虚拟机提供的资源中。
• Java虚拟机是一台执行Java字节码的虚拟计算机，它拥有独立的运行机制，其运行的Java字节码也未必由Java语言编译而成。
• JVM平台的各种语言可以共享Java虚拟机带来的跨平台性、优秀的垃圾回收器，以及可靠的即时编译器。
• Java技术的核心就是Java虚拟机(JVM，Java Virtual Machine) ，因为所有的Java程序都运行在Java虚拟机内部。

java虚拟机作用

Java虚拟机就是二进制字节码的运行环境，负责装载字节码到其内部，解释/编译为对应平台上的机器指令执行。

每一条Java指令，Java虚拟机规范中都有详细定义，如怎么取操作数，怎么处理操作数，处理结果放在哪里。

java虚拟机特点

• 一次编译，到处运行
• 自动内存管理
• 自动垃圾回收功能，

10-JVM的位置

JVM是运行在操作系统之上的，它与硬件没有直接的交互。

JDK,JRE,JVM三者关系图：

前端编译器：比如Javac，它能把.java文件转变成.class字节码文件

后端运行期编译器（JIT编译器，Just In Time Compiler）：把字节码转成机器码

11-JVM的整体结构

HotSpot VM是目前市面上高性能虚拟机的代表作之一。它采用解释器与即时编译器并存的架构。
在今天，Java程序的运行性能早已脱胎换骨，已经达到了可以和C/C+ +程序一较高下的地步。

类加载器子系统把字节码文件装载到内存中，并生成Class对象，涉及到加载，链接，初始化。

多线程共享方法区和堆；java栈，本地方法栈，程序计数器（pc寄存器）每个线程独有一份

执行引擎里分三部分：解释器，JIT编译器，垃圾回收器。操作系统只能识别机器指令，但字节码≠机器指令

要想执行JVM字节码文件，必须借助执行引擎。执行引擎充当了高级语言→机器语言的翻译者。

12-Java代码执行流程

不需要关注前端编译器，除非你要开发一门新的语言，并借助jvm解释运行。

只要让字节码文件符合jvm规范，就可以在jvm上解释执行，即使它不是Java语言开发的。

市面上主流的虚拟机采用解释器与即时编译器并存的方式

当程序需要迅速启动运行的时候，解释器可以先发挥作用，省去编译的时间，立即执行。

热点代码：当虚拟机发现某个方法或代码块的运行特别频繁的时候，就会把这些代码认定为“热点代码”，为了提高其执行效率，在运行时，虚拟机会把这些代码编译成与本地平台相关的机器码，并进行各种层次的优化。完成这个任务的编译器叫做即时编译器(Just In Time Compiler —— JIT编译器)。

13-区分栈的指令集架构和寄存器的指令集架构

JVM架构模型

Java编译器输入的指令流基本上是一种基于栈的指令集架构，另外一种指令集架构则是基于寄存器的指令集架构。

Hotspot虚拟机只有一种寄存器：pc寄存器，所以它是基于栈的指令集架构。

具体来说:这两种架构之间的区别:

• 基于栈式架构的特点

  ➢设计和实现更简单，适用于资源受限的系统;

  ➢避开了寄存器的分配难题:使用零地址指令方式分配。

  ➢指令流中的指令大部分是零地址指令，其执行过程依赖于操作栈。指令集更小，编译器容易实现。.

  ➢不需要硬件支持，可移植性更好，更好实现跨平台

• 基于寄存器架构的特点

  ➢典型的应用是x86的二进制指令集:比如传统的PC以及Android的Davlik虚拟机

  ➢指令集架构则完全依赖硬件，可移植性差

  ➢性能优秀和执行更高效;

  ➢花费更少的指令去完成一项操作。

  ➢在大部分情况下，基于寄存器架构的指令集往往都以一地址指令、二地址指令和三地址指令为主，而基于栈式架构的指令集却是以零地址指令为主。

栈式架构它是零地址指令，每八位进行对齐，每八位为基本单位。指令集更小,但是指令更多

寄存器架构它是每16位为基本单位（双字节方式进行对齐）

基于栈的计算流程(以Java虚拟机为例):

public class StackStruTest {
   //这是java源文件，字节码文件我们程序员看不懂，需要进行反编译
    public static void main(String[] args) {
   
        int i = 2;
        int j = 3;
        int k = i + j;
    }
}

IDEA命令行中使用javap -v反编译字节码文件,可以看出，执行2+3需要八行代码

//这是StackStruTest.class字节码文件通过反编译截取的一部分代码
  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
Code:	//执行的相应指令
  stack=2, locals=4, args_size=1
	  //左边的0-8是pc寄存器识别的地址
     0: iconst_2	//生成常量2
     1: istore_1	//保存到1的操作数栈中，1是操作数栈的索引位置
     2: iconst_3	//生成常量3
     3: istore_2	//保存到2的操作数栈中
     4: iload_1		//加载
     5: iload_2		//加载
     6: iadd		//相加
     7: istore_3	//k保存到3的操作数栈中
     8: return

基于寄存器的计算流程:

只需要两行代码

mov eax,2 //将eax寄存器的值设为2
add eax,3 //使eax寄存器的值加3

总结:

由于跨平台性的设计，Java的指令都是根据栈来设计的。不同平台CPU架构不同，所以不能设计为基于寄存器的。

优点是跨平台，指令集小，编译器容易实现，缺点是性能下降，实现同样的功能需要更多的指令。

14-JVM的生命周期

虚拟机的启动

Java虚拟机的启动是通过引导类加载器（bootstrap class loader）创建一个初始类（initial class）来完成的，这个类是由虚拟机的

具体实现指定的。（由jvm规范定义的，具体实现由具体的jvm虚拟机实现）

Java虚拟机何时启动？自定义类的执行过程是怎样的？

自定义类要执行→父类等必需的类还没加载(Object类等核心api需要由引导类加载器加载)→Java虚拟机启动→创建一个初始类

→调用初始类内部的main方法→加载类

虚拟机的执行

一个运行中的Java虚拟机有着一个清晰的任务：执行Java程序

程序开始执行时他才开始执行，程序结束时他就停止

执行一个所谓的Java程序的时候，真真正正在执行的是一个叫做Java虚拟机的进程

虚拟机的退出

有如下几种情况

• 程序正常执行结束
• 程序在执行过程中遇到了异常或错误而异常终止
• 由于操作系统出现错误而导致Java虚拟机进程终止
• 某线程调用Runtime类或System类的exit方法，或Runtime类的halt方法，并且Java安全管理器也允许这次exit或halt操作。
• 除此之外，JNI(Java Native Interface)规范描述了用JNI Invocation API来加载或卸载Java虚拟机时，Java虚拟机的退出情况。

15-SUN Classic VM的介绍

• 早在1996年Java1. 0版本的时候，Sun公司发布了一款名为sun Classic VM的Java虚拟机，它同时也是世界上第一款商用Java虚拟机，JDK1. 4时完全被淘汰。
• 主流的虚拟机解释器和编译器并存，而这款虚拟机内部只提供解释器。
• 如果使用JIT编译器，就需要进行外挂。但是一旦使用了JIT编译器，JIT就会接管虚拟机的执行系统。解释器就不再工作。解释器和编译器不能配合工作。
• 现在hotspot内置了此虚拟机。.

热点代码：当虚拟机发现某个方法或代码块的运行特别频繁的时候，就会把这些代码认定为“热点代码”，为了提高其执行效率，在运行时，虚拟机会把这些代码编译成与本地平台相关的机器码，并放在方法区缓存起来。

16-Exact VM的介绍

Exact VM

• 为了解决Classic VM问题，jdk1.2时，sun提供了此虚拟机。

• Exact Memory Management:准确式内存管理

  ➢也可以叫Non-Conservative/Accurate Memory Management

  ➢虚拟机可以知道内存中某个位置的数据具体是什么类型。

• 具备现代高性能虚拟机的雏形

  ➢热点探测

  ➢编译器与解释器混合工作模式

• 只在Solaris平台短暂使用，其他平台上还是classic vm

  ➢英雄气短，终被Hotspot虚拟机替换

17-HotSpot VM的介绍

SUN公司的HotSpot VM

• HotSpot历史
  • 最初由一家名为“Longview Technologies"的小公司设计
  • 1997年， 此公司被Sun收购;2009年，Sun公司被甲骨文收购。
  • JDK1.3时， HotSpot VM成为默认虚拟机
• 目前Hotspot占有绝对的市场地位，称霸武林。
  • 不管是现在仍在广泛使用的JDK6,还是使用比例较多的JDK8中， 默认的虚拟机都是HotSpot
  • Sun/Oracle JDK和OpenJDK的默认虚拟机
  • 因此本课程中默认介绍的虚拟机都是HotSpot,相关机制也主要是指HotSpot的GC机制。(比如其他两个商用虚拟机都没有永久代的概念)
• 从服务器、桌面到移动端、嵌入式都有应用。
• 名称中的HotSpot指的就是它的热点代码探测技术。
  • 通过计数器找到最具编译价值代码，触发即时编译或栈上替换
  • 通过编译器与解释器协同工作，在最优化的程序响应时间与最佳执行性能中取得平衡

本课程默认介绍的虚拟机都是HotSpot虚拟机，面试默认问的就是HotSpot。面试时少提另外两个商用虚拟机，别给自己挖坑

在jdk7及以前，习惯上把方法区称为永久代，jdk8开始，使用元空间取代了永久代。

不过元空间与永久代最大的区别在于：元空间不再虚拟机设置的内存中，而是使用本地内存

元空间的本质和永久代类似，都是对JVM规范中方法区的实现。JRockit/J9中不存在永久代的概念

18-JRockit VM的介绍

BEA的JRockit

• 专注于服务器端应用T

  它可以不太关注程序启动速度，因此JRockit内部不包含解析器实现，全部代码都靠即时编译器编译后执行。

• 大量的行业基准测试显示，JRockit JVM是世界上最快的JVM。

  • 使用JRockit产品，客户已经体验到了显著的性能提高(一些超过了70%)和硬件成本的减少(达50%)

• 优势:全面的Java运行时解决方案组合

  • JRockit面向延迟敏感型应用的解决方案JRockit Real Time提供以毫秒或微秒级的JVM响应时间，

    适合财务、军事指挥、电信网络的需要

  • MissionControl服务套件，它是一组以极低的开销来监控、管理和分析生产环境中的应用程序的工具。

• 2008年，BEA被Oracle收购

• Oracle表达了整合两大优秀虚拟机的工作，大致在JDK 8中完成。整合的方式是在HotSpot的基础上，移植JRockit的优秀特性。

• 高斯林:目前就职于谷歌，研究人工智能和水下机器人

19-IBM J9 VM的介绍

• 全称: IBM Technology for Java Virtual Machine, 简称IT4J，内部代号: J9 .
• 市场定位与Hotspot接近，服务器端、桌面应用、嵌入式等多用途VM,广泛用于IBM的各种Java产品。
• 目前，有影响力的三大商用虚拟机之一，也号称是世界上最快的Java虚拟机。
• 2017年左右，IBM发布了开源J9 VM， 命名为openJ9，交给Eclipse基金会管理，也称为Eclipse openJ9

20-KVM、CDC、CLDC的介绍

KVM和CDC/CLDC Hotspot

• Oracle在Java ME产品线上的两款虚拟机为: CDC/CLDC HotSpot Implementation VM

• KVM [Kilobyte)是CLDC-HI早期产品

• 目前移动领域地位尴尬，智能手机被Android和ios二分天下。

• KVM简单、轻量、高度可移植，面向更低端的设备上还维持自己的一片市场.

  ➢智能控制器、传感器

  ➢老人手机、经济欠发达地区的功能手机

• 所有的虚拟机的原则:一次编译，到处运行。

21-Azul VM和BEA Liquid VM的介绍

Azul VM

• 前面三大“高性能Java虚拟机”使用在通用硬件平台上

• 这里Azul VM和BEA Liquid VM是与特定硬件平台绑定、软硬件配合的专有虚拟机,高性能Java 虚拟机中的战斗机。

• Azul VM是Azul Systems公司在HotSpot基础上进行大量改进，运行于Azul systems公司的专有硬件Vega系统上的Java虚拟机。

• 每个Azul VM实例都可以管理至少数十个CPU和数百GB内存的硬件资源，并提供在巨大内存范围内实现可控的GC时间的垃圾

  收集器、专有硬件优化的线程调度等优秀特性。

• 2010年，Azul Systems公司开始从硬件转向软件，发布了自己的Zing JVM，

  可以在通用x86平台上提供接近于vega系统的特性。

Liquid VM

• 高性能Java虚拟机中的战斗机。BEA公司开发的，直接运行在自家Hypervisor系统

• Liquid VM即是现在的JRockit VE (Virtual Edition) , Liquid VM不需要操作系统的支持，

  或者说它自己本身实现了一个专用操作系统的必要功能，如线程调度、文件系统、网络支持等。

• 随着JRockit虚拟机终止开发，Liquid VM项目也停止了。

22-Apache Harmony的介绍

Apache也曾经推出过与JDK 1. 5和JDK 1. 6兼容的Java运行平台Apache Harmony。

它是IBM和Intel联合开发的开源JVM，受到同样开源的0penJDK的压制，Sun坚决不让Harmony获得JCP认证，

最终于2011年退役，IBM转而参与OpenJDK

虽然目前并没有Apache Harmony被大规模商用的案例，但是它的Java类库代码吸纳进了Android SDK。

23-Microsoft JVM和TaobaoJVM

Microsoft JVM

微软为了在IE3浏览器中支持Java Applets,开发了Microsoft JVM。只能在window平台下运行。

但确是当时windows下性能最好的Java VM。

1997年，Sun以侵犯商标、不正当竞争罪名指控微软成功，赔了sun很多钱。

微软在WindowsXP SP3中抹掉了其VM。现在windows上安装的jdk

TaobaoJVM

• 由AliJVM团队发布。阿里，国内使用Java最强大的公司，覆盖云计算、金融、物流、电商等众多领域，

  需要解决高并发、 高可用、分布式的复合问题。有大量的开源产品。

• 基于OpenJDK开发了自己的定制版本AlibabaJDK简称AJDK。是整个阿里Java体系的基石。

• 基于OpenJDK HotSpot VM发布的国内第一个优化、深度定制且开源的高性能服务器版Java虚拟机。

  • 创新的GCIH (GC invisible heap )技术实现了off-heap ，即将生命周期较长的Java对象从heap中移到heap之外，

    并且Gc不能管理GCIH内部的Java对象，以此达到降低GC的回收频率和提升GC的回收效率的目的。

    GCIH中的对象还能够在多个Java虚拟机进程中实现共享

  • 使用crc32指令实现JVM intrinsic 降低JNI的调用开销

  • PMU hardware 的Java profiling tool和诊断协助功能

  • 针对大数据场景的ZenGC

• taobao vm应用在阿里产品上性能高，硬件严重依赖intel的cpu,损失了兼容性，但提高了性能.

  • 目前已经在淘宝、天猫上线，把Oracle 官方JVM版本全部替换了。

未来想学技术，看国内BAT等大厂用什么技术，朝这个方向努力错不了

24-Dalvik VM及其他虚拟机的介绍

Dalvik VM

• 谷歌开发的，应用于Android系统，并在Android2.2中提供了JIT，发展迅猛

• Dalvik VM只能称作虚拟机，而不能称作“Java虚拟机”，它没有遵循Java虚拟机规范，不能直接执行Java 的Class 文件

• 基于寄存器架构，不是jvm的栈架构。

• 执行的是编译以后的dex (Dalvik Executable) 文件。执行效率比较高。

  它执行的dex (Dalvik Executable) 文件可以通过Class文件转化而来，

  使用Java语法编写应用程序，可以直接使用大部分的Java API等。

• Android 5.0 使用支持提前编译(Ahead Of Time Compilation, AOT)的ART VM替换Dalvik VM。（原文件→机器指令）

其他jvm

jvm还有很多，其他的不做介绍了

具体JVM的内存结构，其实取决于其实现。不同厂商的JVM，或者同一厂商发布的不同版本，都有可能存在一定差异。

本套课程主要以Oracle HotSpot VM为默认虚拟机。

25-Graal VM的介绍

• 2018年4月，Oracle Labs公开了Graal VM， 号称"Run Programs Faster Anywhere",勃勃野心。

  与1995年java的”write once， run anywhere "遥相呼应。

• GraalVM在HotSpotVM基础上增强而成的跨语言全栈虚拟机，可以作为“任何语言”的运行平台使用。语言包括: Java、Scala、

  Groovy、Kotlin; C、C++、JavaScript、Ruby、Python、 R等

• 支持不同语言中混用对方的接口和对象，支持这些语言使用已经编写好的本地库文件

• 工作原理是将这些语言的源代码或源代码编译后的中间格式，通过解释器转换为能被Graal VM接受的中间表示。

  Graal VM提供Truffle工具集快速构建面向一种新语言的解释器。在运行时还能进行即时编译优化，获得比原生编译器

  更优秀的执行效率。

• 如果说HotSpot有一天真的被取代，Graal VM希望最大。但是Java的软件生态没有丝毫变化。

第2章：类加载子系统

26-内存结构概述

class文件通过类加载器子系统加载进内存中，执行引擎根据字节码指令依次执行

如果自己手写一个Java虚拟机的话，主要考虑哪些结构呢?

类加载器和执行引擎

类加载器:获取类的信息并装进内存

执行引擎：逐条解释指令

27-概述类的加载器及类加载过程

类加载器子系统作用

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

1.类加载器子系统从文件中读取.class文件加载进内存中并生成Class对象

2.在字节码反编译后可以看到Constant pool（常量池），加载进内存中称为运行时常量池

类加载器ClassLoader角色

1. class file 存在于本地硬盘上，可以理解为设计师画在纸上的模板，而最终这个模板在执行的时候是要加载到JVM当中来
   根据这个文件实例化出n个一模一样的实例。
2. class file 加载到JVM中,被称为DNA元数据模板,放在方法区。
3. 在.class文件-> JVM ->最终成为元数据模板,此过程就要一个运输工具(类装载器 Class Loader), 扮演一个快递员的角色

类的加载过程

类的加载过程简单案例：

public class HelloLoader {
   
	public static void main(String[] args) {
   
		System.out.println("谢谢ClassLoader加载我....");
		System.out.println("你的大恩大德，我下辈子再报! ");
	}
}

当执行HelloLoader的main方法时，过程如图：

28-类的加载过程一：Loading

类的加载过程的第一阶段—加载:Loading（名字恰好也叫加载）

1.通过一个类的全限定名获取定义此类的二进制字节流

2.将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构

3.在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口

方法区是JVM规范，具体实现有永久代或者元空间

在jdk7及以前，习惯上把方法区称为永久代，jdk8开始，使用元空间取代了永久代。

加载.class文件的方式

• 从本地系统中直接加载
• 通过网络获取，典型场景: Web Applet
• 从zip压缩包中读取，成为日后jar、war格式的基础
• 运行时计算生成，使用最多的是:动态代理技术
• 由其他文件生成，典型场景: JSP应用
• 从专有数据库中提取. class文件,比较少见
• 从加密文件中获取，典型的防Class文件被反编译的保护措施

29-类的加载过程二：Linking链接

验证(Verify) :

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

class文件开头都有特定的标识

使用Binary Viewer二进制查看器打开.class文件，都是以cafebabe开头

准备(Prepare) :

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

private static int a = 1;  //准备阶段a还是0，初始化Initialization时才是1

解析(Resolve) :(了解)

• 将常量池内的符号引用转换为直接引用的过程。

• 事实上，解析操作往往会伴随着JVM在执行完初始化之后再执行。

• 符号引用就是一组符号来描述所引用的目标。符号引用的字面量形式明确定义在《java 虚拟机规范》的Class文件格式中。

  直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。

• 解析动作主要针对类或接口、字段、类方法、接口方法、方法类型等。对应常量池中的

  CONSTANT_Class_info、 CONSTANT_Fieldref_info、 CONSTANT_Methodref_info等 。

什么是符号引用？看一个案例

public class HelloApp {
   
    private static int a = 1;//prepare：a = 0 ---> initial : a = 1
    public static void main(String[] args) {
   
        System.out.println(a);
    }
}

执行HelloApp的main方法时，要加载很多结构，不可能把所有结构都装在HelloApp.class里，所以需要符号引用去引用相关结构

反编译HelloApp.class后，可以看到具体的符号引用

30-类的加载过程三：Initialization

初始化

如果没有类变量的赋值动作和静态代码块，那么不会生成()

即使是空的静态代码块，也会生成()

---

初始化:

• 初始化阶段就是执行类构造器方法 ()过程。
• 此方法不需定义，是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并而来。
• 构造器方法中指令按语句在源文件中出现的顺序执行。
• ()不同于类的构造器。(关联: 构造器是虚拟机视角下的() )
  若该类具有父类，JVM会保证子类的()执行前，父类的 ()已经执行完毕。
• 虚拟机必须保证一个类的 ()方法在多线程下被同步加锁。

---

案例一：

public class ClassInitTest {
   
   private static int num = 1;

   static{
   
       num = 2;
       number = 20;
       System.out.println(num);
       //System.out.println(number);//报错：非法的前向引用，后面定义的变量在前面的静态代码块可以赋值，不可以引用。
   }

   private static int number = 10;  //linking之prepare: number = 0 --> initial: 20 --> 10
 
    public static void main(String[] args) {
   
        System.out.println(ClassInitTest.num);//2
        System.out.println(ClassInitTest.number);//10
    }
}

其实就是构造器函数

---

使用IDEA的插件jclasslib查看字节码文件更快捷

先装插件，装好后重启IDEA

对着原文件Build–>重新编译，然后view–>jclasslib显示字节码

---

案例二:打印结果是多少？

public class ClinitTest1 {
   
    static class Father{
   
        public static int A = 1;
        static{
   
            A = 2;
        }
    }

    static class Son extends Father{
   
        public static int B = A;
    }

    public static void main(String[] args) {
   
        //加载Father类，其次加载Son类。
        System.out.println(Son.B);//2
    }
}

执行过程：首先找到程序的入口main方法，打印时发现用到另一个类Son的类变量B，

那么会先加载Son类的父类Father的,然后在加载Son的,其实就是构造器方法

31-几种类加载器的使用体会

类加载器的分类

• 引导类加载器(Bootstrap ClassLoader)
• 自定义类加载器(User- Defined ClassLoader)

从概念上来讲，自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器，

但是Java虚拟机规范却没有这么定义，而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器。

无论怎么分类，在程序中我们最常见的类加载器始终只有3个，引导类加载器、扩展类加载器、系统类加载器

这里的四者之间的关系是包含关系。不是子父类的继承关系（引导类加载器不是由java语言写的,跟继承无任何关系)。

public class ClassLoaderTest {
   
    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

        //对于用户自定义类来说：默认使用系统类加载器进行加载
        //getClassLoader():获取类加载器。对于任何一个类，都可以知道它是被谁加载的
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //String类使用引导类加载器进行加载的。---> Java的核心类库都是使用引导类加载器进行加载的。
        ClassLoader classLoader1 = String.class.getClassLoader();
        System.out.println(classLoader1);//null
    }
}

32-引导类、扩展类、系统类加载器的使用及演示

虚拟机自带的加载器

• 启动类加载器(引导类加载器，Bootstrap ClassLoader)

  ➢这个类加载使用C/C++语言实现的，嵌套在JVM内部。

  ➢它用来加载Java的核心库(JAVA_ HOME/ jre/lib/rt.jar、resources. jar或sun. boot.class.path路径下的内容) ,

  用于提供JVM自身需要的类

  ➢并不继承自java. lang. ClassLoader,没有父加载器。

  ➢加载扩展类和应用程序类加载器，并指定为他们的父类加载器。

  ➢出于安全考虑，Bootstrap启动类加载器只加载包名为java、javax、sun等开头的类

• 扩展类加载器(Extension ClassLoader)

  ➢Java语言编写，由sun. misc. Launcher$ExtClassLoader实现。

  ➢派生于ClassLoader类

  ➢父类加载器为启动类加载器

  ➢从java.ext.dirs系统属性所指定的目录中加载类库，或从JDK的安装目录的jre/lib/ext子目录(扩展目录)下加载类库。

  如果用户创建的JAR放在此目录下，也会自动由扩展类加载器加载。

• 应用程序类加载器(系统类加载器AppClassLoader )

  ➢java语言 编写，由sun .misc. Launcher$AppClassLoader实现

  ➢派生于ClassLoader类

  ➢父类加载器为扩展类加载器

  ➢它负责加载环境变量classpath（自定义的类生成的路径）或系统属性java. class.path指定路径下的类库

  ➢该类加载器是程序中默认的类加载器，一般来说，Java应用的类都是由它来完成加载

  ➢通过ClassLoader #getSystemClassLoader ()方法可以获取到该类加载器

演示案例：（了解即可）

public class ClassLoaderTest1 {
   
    public static void main(String[] args) {
   
        System.out.println("**********启动类加载器**************");
        //获取BootstrapClassLoader能够加载的api的路径
        URL[] urLs = sun.misc.Launcher.getBootstrapClassPath().getURLs();
        for (URL element : urLs) {
   
            System.out.println(element.toExternalForm());
        }
        //从上面的路径中随意选择一个类,来看看他的类加载器是什么:引导类加载器
        ClassLoader classLoader = Provider.class.getClassLoader();
        System.out.println(classLoader);

        System.out.println("***********扩展类加载器*************");
        String extDirs = System.getProperty("java.ext.dirs");
        for (String path : extDirs.split(";")) {
   
            System.out.println(path);
        }

        //从上面的路径中随意选择一个类,来看看他的类加载器是什么:扩展类加载器
        ClassLoader classLoader1 = CurveDB.class.getClassLoader();
        System.out.println(classLoader1);//sun.misc.Launcher$ExtClassLoader@1540e19d

    }

33-为什么需要用户自定义类加载器及具体实现

用户自定义类加载器

在Java的日常应用程序开发中，类的加载几乎是由上述3种类加载器相互配合执行的，

在必要时，我们还可以自定义类加载器，来定制类的加载方式。

为什么要自定义类加载器?

➢隔离加载类

➢修改类加载的方式

➢扩展加载源

➢防止源码泄漏

---

用户自定义类加载器实现步骤:

1.开发人员可以通过继承抽象类java. lang. ClassLoader类的方式，实现自己的类加载器，以满足一些特殊的需求

2.在JDK1.2之前，在自定义类加载器时，总会去继承ClassLoader类并重写loadClass()方法，从而实现自定义的类加载类，

但是在JDK1.2之后已不再建议用户去覆盖loadClass()方法，而是建议把自定义的类加载逻辑写在findClass ()方法中

3.在编写自定义类加载器时，如果没有太过于复杂的需求，可以直接继承URLClassLoader类，这样就可以避免自己去编写findClass()方法

及其获取字节码流的方式，使自定义类加载器编写更加简洁。

/**
 * 自定义用户类加载器(了解个大概即可)
 * @author shkstart
 * @create 2019 下午 12:21
 */
public class CustomClassLoader extends ClassLoader {
   
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
   

        try {
   
            byte[] result = getClassFromCustomPath(name);
            if(result == null){
   
                throw new FileNotFoundException();
            }else{
   	//findClass和defineClass组合使用
                return defineClass(name,result,0,result.length);
            }
        } catch (FileNotFoundException e) {
   
            e.printStackTrace();
        }

        throw new ClassNotFoundException(name);
    }

    private byte[] getClassFromCustomPath(String name){
   
        //从自定义路径中加载指定类（使用流）:细节略
        //如果指定路径的字节码文件进行了加密，则需要在此方法中进行解密操作。
        return null;
    }

    public static void main(String[] args) {
   
        CustomClassLoader customClassLoader = new CustomClassLoader();
        try {
   
            Class<?> clazz = Class.forName("One",true,customClassLoader);
            Object obj = clazz.newInstance();
            System.out.println(obj.getClass().getClassLoader());
        } catch (Exception e) {
   
            e.printStackTrace();
        }
    }
}

34-ClassLoader的常用方法及获取方法

ClassLoader类，它是一个抽象类，其后所有的类加载器都继承自ClassLoader (不包括启动类加载器)

获取ClassLoader的方式

方式一:获取当前类的ClassLoader	clazz. getClassLoader （）
方式二:获取当前线程上下文的ClassLoader	Thread. currentThread（） . getContextClassLoader（）
方式三:获取系统的ClassLoader	ClassLoader. getSystemClassLoader（）
方式四:获取调用者的ClassLoader	DriverManager. getCallerClassLoader（）

35-双亲委派机制的工作原理及演示

Java虚拟机对Class文件采用的是按需加载的万式，也就是说当需要使用该类时才会将它的class文件加载到内存生成class对象。

而且加载某个类的class文件时，Java虚拟机采用的是双亲委派模式，即把请求交由父类处理,它是一种任务委派模式。

工作原理

1)如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行;

2)如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归,请求最终将到达项层的启动类加载器;

3)如果父类加载器可以完成类加载任务，就成功返回，如果父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，

这就是双亲委派模式。

36-双亲委派机制的优势

• 避免类的重复加载
• 保护程序安全，防止核心API被随意篡改

37-沙箱安全机制

自定义String类，但是在加载自定义String类的时候会率先使用引导类加载器加载，而引导类加载器在加载的过程中会先加载jdk自

带的文件(rt. jar包中java \lang\String. class)，报错信息说没有main方法，就是因为加载的是rt . jar包中的String类。这样可以保证

对java核心源代码的保护，这就是沙箱安全机制。

38-类的主动使用与被动使用等

在JVM中表示两个class对象是否为同一个类存在两个必要条件:

• 类的完整类名必须一致，包括包名。

• 加载这个类的ClassLoader (指ClassLoader实例对象)必须相同。

  换句话说，在JVM中，即使这两个类对象(class对象)来源同一个Class文件，被同一个虚拟机所加载，

  但只要加载它们的ClassLoader实例对象不同，那么这两个类对象也是不相等的。

对类加载器的引用

JVM必须知道–个类型是由启动加载器加载的还是由用户类加载器加载的。如果一个类型是由用户类加载器加载的，那么JVM会将这

个类加载器的一个引用作为类型信息的一部分保存在方法区中。当解析一个类型到另一个类型的引用的时候，JVM需要保证这两

个类型的类加载器是相同的。(动态链接有详细解释)

类的主动使用和被动使用

Java程序对类的使用方式分为:主动使用和被动使用。

主动使用，又分为七种情况:

• 创建类的实例

• 访问某个类或接口的静态变量，或者对该静态变量赋值

• 调用类的静态方法

• 反射(比如: Class. forName (“com. atguigu . Test") )

• 初始化一个类的子类

• Java虚拟机启动时被标明为启动类的类

• JDK 7开始提供的动态语言支持:

  java.lang.invoke.MethodHandle实例的解析结果

  REF_getStatic、 REF_putStatic、 REF_invokeStatic句柄对应的类没有初始化，则初始化

  除了以上七种情况，其他使用Java类的方式都被看作是对类的被动使用，都不会导致类的初始化。

39-运行时数据区内部结构

内存是非常重要的系统资源，是硬盘和CPU的中间仓库及桥梁，承载着操作系统和应用程序的实时运行。JVM内存布局规定了Java

在运行过程中内存申请、分配、管理的策略，保证了JVM的高效稳定运行。

**不同的JVM对于内存的划分方式和管理机制存在着部分差异。**结合JVM虚拟机规范，来探讨一下经典的JVM内存布局。

详细图

Java虚拟机定义了若干种程序运行期间会使用到的运行时数据区，其中有一些会随着虚拟机启动而创建，随着虚拟机退出而销毁。

另外一些则是与线程一一对应的， 这些与线程对应的数据区域会随着线程开始和结束而创建和销毁。

灰色的为单独线程私有的，红色的为多个线程共享的。即:

• 每个线程:独立包括程序计数器、栈、本地栈。
• 线程间共享:堆、堆外内存(永久代或元空间、代码缓存)

代码缓存是jit编译产物

每个JVM只有一个Runtime实例。即为运行时环境，相当于内存结构的中间的那个框框:运行时环境。

40-JVM中的线程说明

• 线程是一个程序里的运行单元。JVM允许一个应用有多个线程并行的执行。

• 在HotspotJVM里，每个线程都与操作系统的本地线程直接映射。

  ➢当一个Java线程准备好执行以后，此时一个操作系统的本地线程也同时创建。Java线程执行终止后，本地线程也会回收。

• 操作系统负责所有线程的安排调度到任何一个可用的CPU上。一旦本地线程初始化成功，它就会调用Java线程中的run()方法。

程序执行的过程中，如果有些异常没有处理，那么Java线程就会中止。本地线程会决定JVM到底要不要终止，如果当前Java线程

是最后一个非守护线程，JVM就会终止。

什么是守护线程？

可以看这里

jvm系统线程

如果你使用jconsole或者是任何一个调试工具，都能看到在后台有许多线程在运行。

这些后台线程不包括调用public static void main (String[])的main线程以及所有这个main线程自己创建的线程。

这些主要的后台系统线程在Hotspot JVM里主要是以下几个:（了解）

• 虚拟机线程:这种线程的操作是需要JVM达到安全点才会出现。

  这些操作必须在不同的线程中发生的原因是他们都需要JVM达到安全点，这样堆才不会变化。

  这种线程的执行类型包括"stop-the-world"的垃圾收集，线程栈收集，线程挂起以及偏向锁撤销。

• 周期任务线程 :这种线程 是时间周期事件的体现(比如中断)，他们一般用于周期性操作的调度执行。

• GC线程:这种线程对在JVM里不同种类的垃圾收集行为提供了支持。

• 编译线程:这种线程在运行时会将字节码编译成到本地代码。

• 信号调度线程:这种线程接收信号并发送给JVM，在它内部通过调用适当的方法进行处理。

第4章：程序计数器

41-PC寄存器概述

https://docs.oracle.com/javase/specs/jvms/se8/html/index.html官网也有详解

PC寄存器介绍

PC寄存器，(Program Counter Register) 也叫程序计数器，程序计数寄存器。

JVM中的程序计数寄存器中，Register 的命名源于CPU的寄存器，寄存器存储指令相关的现场信息。

CPU只有把数据装载到寄存器才能够运行。这里，并非是广义上所指的物理寄存器，或许将其翻译为PC计数器(或指令计数器)会更

加贴切(也称为程序钩子)，并且也不容易引起一些不必要的误会。JVM中的PC寄存器是对物理PC寄存器的一种抽象模拟。

程序钩子：程序是线程中一行行执行的代码，钩子勾着一行行代码。

作用:

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

它是一块很小的内存空间，几乎可以忽略不记。也是运行速度最快的存储区域。

在JVM规范中，每个线程都有它自己的程序计数器，是线程私有的，生命周期与线程的生命周期保持

一致。

任何时间一个线程都只有一个方法在执行，也就是所谓的当前方法。

程序计数器会存储当前线程正在执行的Java方法的JVM指令地址；

或者，如果是在执行native方法，则是未指定值(undefined)

它是程序控制流的指示器，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。

字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令。

它是唯一一个在Java虛拟机规范中没有规定任何OutOtMemoryError情况的区域。

虚拟机栈，本地方法栈只有入栈出栈操作，没有GC（垃圾回收机制），但有可能OOM(内存溢出)

pc寄存器没有GC也不会OOM

42-PC寄存器的使用举例

public class PCRegisterTest {
   

    public static void main(String[] args) {
   
        int i = 10;
        int j = 20;
        int k = i + j;

        String s = "abc";
        System.out.println(i);
        System.out.println(k);
    }
}

首先进行反编译，不会IDEA反编译可以查看这里

反编译后就可以查看到相应指令了

//这里只列出部分指令，更详细指令请自行反编译
    Code:
      stack=2, locals=5, args_size=1
         0: bipush        10
         2: istore_1
         3: bipush        20
         5: istore_2
         6: iload_1
         7: iload_2
         8: iadd
         9: istore_3
        10: ldc           #2                  // String abc
        12: astore        4
        14: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
        17: iload_1
        18: invokevirtual #4                  // Method java/io/PrintStream.println:(I)V
        21: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
        24: iload_3
        25: invokevirtual #4                  // Method java/io/PrintStream.println:(I)V
        28: return

结合下图搞懂pc寄存器的意义

指令地址：pc寄存器中存储的结构

操作指令：中篇字节码再详细讲解

上图表示的是执行引擎会去pc寄存器5的位置取指令，然后操作局部变量表，操作数栈，实现数据存取的操作

还会将字节码指令翻译成机器指令，供cpu执行

43-解决PC寄存器两个面试问题

使用PC寄存器存储字节码指令地址有什么用呢?
为什么使用PC寄存器记录当前线程的执行地址呢?

因为CPU需要不停的切换各个线程，这时候切换回来以后，就得知道接着从哪开始继续执行。

JVM的字节码解释器就需要通过改变PC寄存器的值来明确下一条应该执行什么样的字节码指令。

PC寄存器为什么会被设定为线程私有?

我们都知道所谓的多线程在一个特定的时间段内只会执行其中某一个线程的方法， CPU会不停地做任

务切换，这样必然导致经常中断或恢复，如何保证分毫无差呢?

为了能够准确地记录各个线程正在执行的当前字节码指令地址，最好的办法自然是为每一个线程都分

**配一个PC寄存器，**这样一来各个线程之间便可以进行独立计算，从而不会出现相互干扰的情况。

由于CPU时间片轮限制，众多线程在并发执行过程中，任何一个确定的时刻，一个处理器或者多核处

理器中的一个内核，只会执行某个线程中的一条指令。

这样必然导致经常中断或恢复，如何保证分毫无差呢?

每个线程在创建后，都会产生自己的程序计数器和栈帧，程序计数器在各个线程之间互不影响。

cpu时间片

CPU时间片即CPU分配给各个程序的时间，每个线程被分配一个时间段，称作它的时间片。

在宏观上:我们可以同时打开多个应用程序，每个程序并行不悖，同时运行。

但在微观上:由于只有一个CPU，一次只能处理程序要求的一部分，

如何处理公平，一种方法就是引入时间片，每个程序轮流执行。

第5章：虚拟机栈:

44-虚拟机栈的主要特点

虚拟机栈出现的背景：

由于跨平台性的设计，Java的指令都是根据栈来设计的。不同平台CPU架构不同，所以不能设计为基于寄存器的。

优点是跨平台，指令集小，编译器容易实现，缺点是性能下降，实现同样的功能需要更多指令。

有不少Java开发人员一提到Java内存结构，就会非常粗粒度地将JVM中的内存区

理解为仅有Java堆(heap)和Java栈(stack)?为什么?

内存中的栈和堆

栈是运行时的单位，而堆是存储的单位。

是数据存储的问题，即数据怎么放、放在哪儿。

即:栈解决程序的运行问题，即程序如何执行，或者说如何处理数据。

堆解决的是数据存储的问题，即数据怎么放、放在哪儿。

（Java是面向对象的，主体上数据（对象）放在堆中。栈也是可以存放数据的，存放局部变量，引用类型的地址）

Java虚拟机栈是什么?

Java虚拟机栈（Java Virtual Machine stack），早期也叫Java栈。

每个线程在创建时都会创建一个虚拟机栈，其内部保存一个个的栈帧(stack Frame)

对应着一次次的Java方法调用。是线程私有的

生命周期：

生命周期和线程一致。

作用：

主管Java程序的运行，它保存方法的局部变量（8种基本数据类型、对象的引用地址）、部分结果，

并参与方法的调用和返回。

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

栈的特点（优点）

1.栈是一种快速有效的分配存储方式，访问速度仅次于程序计数器。

2.JVM直接对Java栈的操作只有两个:每个方法执行，伴随着进栈(入栈、压栈)，执行结束后的出栈工作

3.对于栈来说不存在垃圾回收问题（补充：无GC，有OOM）

45-虚拟机栈的常见异常与如何设置栈大小

面试题:开发中遇到的异常有哪些?

栈中可能出现的异常

• Java虚拟机规范允许Java栈的大小是动态的或者是固定不变的。如果采用固定大小的Java虚拟机栈，

  那每一个线程的Java虚拟机栈容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过Java

  虚拟机栈允许的最大容量，Java虚拟机将会抛出一个stackoverflowError异常。

• 如果Java虚拟机栈可以动态扩展，并且在尝试扩展的时候无法中请到足够的内存，

  或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈,

  那Java虚拟机将会抛出一个OutOfMemoryError异常。

设置栈内存大小

我们可以使用参数-Xss选项来设置线程的最大栈空间，栈的大小直接决定了函数调用的最大可达深度。

参考官网

简单案例：

public class StackErrorTest {
   
    private static int count=1;
    public static void main(String[] args) {
   
        System.out.println(count);
        count++;
        main(args);
    }
}

46-栈的存储结构和运行原理

栈中存储什么?

每个线程都有自己的栈，栈中的数据都是以栈帧(stack Frame)为基本单位存在

在这个线程上正在执行的每个方法都各自对应一个栈帧（stack Frame)

栈帧是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据信息。

栈的运行原理

JVM直接对Java栈的操作只有两个，就是对栈帧的压栈和出栈，遵循先进后出/后进先出原则。

在一条活动线程中，一个时间点上，只会有一个活动的栈帧。

即只有当前正在执行的方法的栈帧（栈顶栈帧）是有效的，这个栈帧被称为当前栈帧(Current Frame），

与当前栈帧相对应的方法就是当前方法（Current Method），定义这个方法的类就是当前类(Current

class）。

执行引擎运行的所有字节码指令只针对当前栈帧进行操作。

如果在该方法中调用了其他方法，对应的新的栈帧会被创建出来，放在栈的顶端，成为新的当前帧。

不同线程中所包含的栈帧是不允许存在相互引用的，即不可能在一个栈帧之中引用另外一个线程的栈帧。

如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着，

虚拟机会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧。

Java方法有两种返回函数的方式，一种是正常的函数返回，使用return指令;

另外一种是抛出异常(未处理的）。不管使用哪种方式，都会导致栈帧被弹出。

47-栈桢的内部结构

一个栈可以放几个栈帧取决于栈帧的大小。栈帧的大小取决于栈帧内部的结构

多线程下栈帧

48-局部变量表结构的认识

局部变量表（Iocal variables)

• 局部变量表也被称之为局部变量数组或本地变量表

• 定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量，

  这些数据类型包括各类基本数据类型、对象引用(reference），以及returnAddress类型。

• 由于局部变量表是建立在线程的栈上，是线程的私有数据，因此不存在数据安全问题

• 局部变量表所需的容量大小是在编译期确定下来的，并保存在方法的Code属性的maximum

  local variables数据项中。在方法运行期间是不会改变局部变量表的大小的。

**方法嵌套调用的次数由栈的大小决定。**一般来说，栈越大，方法嵌套调用次数越多。

对一个函数而言，它的参数和局部变量越多，使得局部变量表膨胀，它的栈帧就越大，以满足方法调用所需传递的

信息增大的需求。进而函数调用就会占用更多的栈空间，导致其嵌套调用次数就会减少。

**局部变量表中的变量只在当前方法调用中有效。**在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量

列表的传递过程。当方法调用结束后，随着方法栈帧的销毁，局部变量表也会随之销毁。

49-字节码中方法内部结构的剖析

演示案例：

public class LocalVariablesTest {
   
    public static void main(String[] args) {
   
        LocalVariablesTest test = new LocalVariablesTest();
        Date date =new Date();
        int count =10;
        System.out.println(count);
    }

    public static void test(){
   
        String str="test";
    }
}

jclasslib图解：

（1)

(2)Code length是字节码指令的长度，字节码指令和javap -v一致，左边的数字表示行号

 0 new #2 <LocalVariablesTest>
 3 dup
 4 invokespecial #3 <LocalVariablesTest.<init>>
 7 astore_1
 8 new #4 <java/util/Date>
11 dup
12 invokespecial #5 <java/util/Date.<init>>
15 astore_2
16 bipush 10
18 istore_3
19 getstatic #6 <java/lang/System.out>
22 iload_3
23 invokevirtual #7 <java/io/PrintStream.println>
26 return

(3)

（4）length不是终止位置，是长度，表示的是变量的作用域从Start PC开始，往后加length行

50-变量槽slot的理解与演示

• 参数值的存放总是在局部变量数组的index0开始，到数组长度-1的索引结束。

• 局部变量表，最基本的存储单元是slot(变量槽）

• 局部变量表中存放编译期可知的各种基本数据类型(8种)，引用类型(reference)，returnAddress类型的变量。

• 在局部变量表里，32位以内的类型只占用一个slot（包括returnAddress类型），64位的类型（long和double)占用两个slot。(补充：引用类型和float类型也占32位)

• byte，short，char在存储前被转换为int，boolean也被转换为int，0表示false ，非0表示true。long和double则占据两个slot。（long和double都是8个字节=64位）

关于slot的理解

• JVM会为局部变量表中的每一个slot都分配一个访问索引，通过这个索引即可成功访问到局部变量表中指定的局部变量值
• 当一个实例方法被调用的时候，它的方法参数和方法体内部定义的局部变量将会按照顺序被复制到局部变量表中的每一个slot上
• 如果需要访问局部变量表中一个64bit的局部变量值时，只需要使用前一个索引即可。(比如:访问long或double类型变量）
• 如果当前帧（方法）是构造方法或者实例方法，那么该对象引用this将会存放在index为0的slot处，其余的参数按照参数表顺序继续排列。（理解：构造方法和实例方法用到this，this也是一个变量。静态方法中不能使用this，原因是this变量不存在于当前方法的局部变量表）

案例：

public void test1(){
   
    double weight=90.5;
    char gender='男';
    Date date =null;
    long l=100L;
}

可以看出：long和double类型都是占两个slot。（补充一点:包装类也是引用类型，Double只占一个slot）

Slot重复利用