1. 为什么需要性能优化

在本地开发环境一般很少遇到对JVM优化的需求,但是到了生产环境,可能会有以下的需求
1.运行的应用卡住了,日志不输出,程序没有反应
2.服务器的CPU负载突然增高
3.在多线程情况下,如何分配线程的数量
4.新项目上线,对各种JVM参数设置很茫然然后就JJ?
...

应用架构

2. JVM的整体架构

JVM的整体架构

代码 idea 反编译指令 javap - v 类名

public class Test1 {
    public static void main(String[] args) {
        int i = 2 + 3;
        int j = 7+4;
        int k = i+j;
    }
}

Java指令

3. Java代码的执行流程

Java程序 [.java文件] ==>> 编译 字节码文件 [.class文件] ==>> 运行 任何含有JVM的机器
Java属于高级语言 高级语言编译为汇编语言,汇编编译成二进制文件 然后运行

4. JVM的生命周期

1.JVM的启动
Java虚拟机的启动时通过引导类加载器(bootstrap class looader) 创建一个初始类 (initial class) 来完成的,这个类是由虚拟机的具体实现指定的

2.虚拟机的执行

• 一个运行中的Java虚拟机有着一个清晰的任务:执行Java程序
• 程序开始执行它才执行,程序结束它就结束
• 执行一个所谓的Java程序的时候,才真正叫做一个Java虚拟机的进程

3.JVM的退出

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

5. JVM的发展历程

Sun Classic VM
第一款商用虚拟机 在 1.4 淘汰

Exact VM
热点探测 编译器和解释器混合工作模式 为了解决上一个虚拟机的问题

SUN公司的 HotSpot VM
目前此虚拟机占有绝对的市场地位 在JDK1.3就是默认的虚拟机

EBA 的 JRockit
专注于服务端应用 内部不含有解析器实现 是世界上最快的JVM

IBM J9 VM
有影响力的三大商用虚拟机之一 也号称是世界上最快的Java虚拟机

KVM 和 CDC/ Hotpot
JavaME层面
现在市场在老年机等

Azul VM
和特定平台绑定,软硬件配合的专有虚拟机
Azul VM是Azul Systems 公司在HotSpot基础上进行大量改进,运行于Azul Systems 公司的专有硬件系统的 Vega 系统的上的JVM
每个Azul VM实例都可以管理至少数十个CPU和数百GB内存的硬件资源,并提高在巨大内存范围是实现可控制的GC时间的垃圾回收器,专有硬件优化的线程调度等优秀特性

Liquid VM
BEA公司开发的,直接运行在自家 Hypervisor系统上
不需要操作系统的支持,或者说它本身就实现了一个专用操作系统的功能,如线程调度,文件系统,网络支持等

Apache Harmony
与JDK1.5和JDK1.6兼容的Java运行平台
但是在Android SDK有大范围的应用

Microsoft VM
为了在IE3中更好的支持 Java Applets 而开发 只能在Windows下运行 当时很nb
但是被侵权了,后来就GG了

Taobao JVM
阿里巴巴基于OpenJDK开发自己的定制版本AlibabaJDK,简称AJDK.是整个阿里Java体系的基石
基于OpenJDK HotSpot VM发布的国内第一个优化,深度定制且开源的高性能服务器版本JVM
创新的GCHI(GC invusible heap)技术实现了off-heap,即将生命周期较长的Java对象从heap移到heap之外,并且GC不能管理GCHI内部对Java对象,以此达到降低GC的回收频率和提高GC的回收效率
GCHI中的对象还能再多个Java虚拟机进程中共享

Dalvik VM
谷歌开发的,应用于Android系统 并在Android2.2提供了JIT 发展迅猛
只能叫做虚拟机,而不是"Java 虚拟机" 没有遵循Java虚拟机规范
不能直接运行class文件
基于寄存器架构,不是JVM的架构

Graal VM
2018年4月 Oracle公布
Graal VM 基于 HotSpot VM 增加而成的 跨语言全栈虚拟机 可以作为"任何语言"的运行平台使用

6. 类的加载器以及类的加载过程

类加载器子系统

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

举例

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

类的加载过程 加载

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

加载字节码文件的方式

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

类的加载过程 链接 - 验证 Verify

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

类的加载过程 链接 - 准备 Prepare

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

类的加载过程 链接 - 解析 Resolve

• 将常量池的符号引用转换为直接引用的过程
• 事实上.解析操作往往会伴随着JVM在执行玩初始化之后再进行
• 符号引用就是一组符号来描述所引用的目标.符号引用的字面量形式明确定义在 <<Java虚拟机规范>>的Class文件格式中,直接引用就是直接指向目标的地址,相对偏移量或者一个间接定位到目标的句柄
• 解析动作主要是 针对类会或接口 字段 类方法 接口方法 方法类型等.对应常量池中的 CONSTANT_Class_info CONSTANT_Fieldref_info CONSTANT_MethodRef_info等

类的加载过程 初始化

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

类加载器的分类

• JVM支持两种类型的类加载器,分别是引导类加载器(Bootstrap ClassLoader) 和 自定义类加载器(User-Defined ClassLoader)
• 从概念上讲,自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器,但是Java虚拟机规范却没有这么定义,而是将所有怕派生于抽象类ClassLoader的类加载器都划分为自定义类加载器

• 无论类加载器的类型如何划分,在程序中我们最常见的类加载器始终只有3个.如下:
  Bootstrap Class Loader
  Extension Class Loader
  System Class Loader

  
  
  其他的加载器

案例

package cn.icanci.jvm;

/**
 * @Author: icanci
 * @ProjectName: jvm
 * @PackageName: cn.icanci.jvm
 * @Date: Created in 2020/2/17 14:28
 * @ClassAction: 加载器
 */
public class ClassLoderTest {
    public static void main(String[] args) {
        //获取系统类加载器

        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        //sun.misc.Launcher$AppClassLoader@18b4aac2
        System.out.println(systemClassLoader);

        //获取其上层:拓展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        //sun.misc.Launcher$ExtClassLoader@1540e19d
        System.out.println(parent);

        //再获取上层 :获取不到引导类加载器
        ClassLoader parent1 = parent.getParent();
        //null 这个是 Bootstrap Class Loader
        System.out.println(parent1);

        //对于用户自定义的
        ClassLoader classLoader = ClassLoderTest.class.getClassLoader();
        //sun.misc.Launcher$AppClassLoader@18b4aac2
        System.out.println(classLoader);

        ClassLoader parent2 = classLoader.getParent();
        //sun.misc.Launcher$ExtClassLoader@1540e19d
        System.out.println(parent2);
        ClassLoader parent3 = parent2.getParent();
        //null
        System.out.println(parent3);

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

虚拟机自带的加载器

• 启动类加载器(引导类加载器 Bootstrap ClassLoader)
  这个类加载器是使用C/C++语言实现的.嵌套到JVM内部
  它用来加载Java的核心库(JAVA_HOMT/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()方法可以获取该类加载器

案例

package cn.icanci.jvm;

import sun.misc.Launcher;

import javax.crypto.spec.OAEPParameterSpec;
import java.net.URL;
import java.nio.file.attribute.UserDefinedFileAttributeView;
import java.security.Provider;

/**
 * @Author: icanci
 * @ProjectName: jvm
 * @PackageName: cn.icanci.jvm
 * @Date: Created in 2020/2/17 14:55
 * @ClassAction: 获取加载的那些文件
 */
public class ClassLoaderTest2 {
    public static void main(String[] args) {
        System.out.println("启动类加载器");
        URL[] urLs = Launcher.getBootstrapClassPath().getURLs();
        for (URL url :urLs){
            System.out.println(url.toExternalForm());
        }
        //从上面的路径任意选择一个类 看看类的加载器是什么 引导类加载器 null
        
        ClassLoader classLoader = Provider.class.getClassLoader();
        System.out.println(classLoader);

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

打印结果

启动类加载器
file:/D:/jdk/jdk1.8/jre/lib/resources.jar
file:/D:/jdk/jdk1.8/jre/lib/rt.jar
file:/D:/jdk/jdk1.8/jre/lib/sunrsasign.jar
file:/D:/jdk/jdk1.8/jre/lib/jsse.jar
file:/D:/jdk/jdk1.8/jre/lib/jce.jar
file:/D:/jdk/jdk1.8/jre/lib/charsets.jar
file:/D:/jdk/jdk1.8/jre/lib/jfr.jar
file:/D:/jdk/jdk1.8/jre/classes
null
拓展类加载器
D:\jdk\jdk1.8\jre\lib\ext
C:\WINDOWS\Sun\Java\lib\ext

用户自定义类加载器

• 在Java的日常应用程序开发中,类的加载几乎是由上述3种类加载器相互配合执行的,在必要的时候,可以自定义类加载器,来定制类的加载方式
• 为什么要自定义类加载器
  1.隔离加载类
  2.修改类的加载方式
  3.拓展加载源
  4.防止源码泄露

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

• 开发人员可以通过继承抽象类 java.lang.ClassLoader类的方式,实现自己的类加载器,以满足一些特殊的需求
• 在JDK1.2之前,在自定义类加载器的时候,总会去继承ClassLoader类并重写LoadClass()方法,从而实现自定义的类加载类,但是在JDK1.2以后,已经不再建议用户覆盖loadClass()方法,而是建议把自定义的类加载逻辑卸载findClass()方法中
• 在编写自定义类加载器时候,如果没有太过于复杂的需求,可以直接继承 URLClassLoader类,这样就可以避免自己去编写findClass()方法以及器获取字节码流的方式,使得自定义加载器编写更加简洁

实例

package cn.icanci.jvm;

/**
 * @Author: icanci
 * @ProjectName: jvm
 * @PackageName: cn.icanci.jvm
 * @Date: Created in 2020/2/17 15:59
 * @ClassAction: 用户自定义类加载器
 */
public class ClassLoaderTest3 extends ClassLoader {
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] result = getClassFromCustomerPath(name);
        try {
            if (result==null){
                throw new ClassNotFoundException();
            }else {
                return defineClass(name,result,0,result.length);
            }
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        }
        throw new ClassNotFoundException();
    }

    private static byte[] getClassFromCustomerPath(String name){
        //自定义路径中加载指定路径
        return null;
    }
}

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

获取ClassLoader

• 方式1:获取当前类的ClassLoader
  ClassLoader classLoader = Class.forName("java.lang.String").getClassLoader();
  System.out.println(classLoader);
• 方式2:获取当前线程上下文的ClassLoader
  ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
  System.out.println(contextClassLoader);
• 方式3:获取系统的ClassLoader
  ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
  System.out.println(systemClassLoader);
• 方式4:获取调用者的ClassLoader
  DriverManager.getCallerClassLoader();

实例代码

package cn.icanci.jvm;

import java.sql.DriverManager;

/**
 * @Author: icanci
 * @ProjectName: jvm
 * @PackageName: cn.icanci.jvm
 * @Date: Created in 2020/2/17 16:14
 * @ClassAction: 获取Classloader
 */
public class ClassLoaderTest4 {
    public static void main(String[] args) {
        try {
            //方式1:获取当前类的ClassLoader
            ClassLoader classLoader = Class.forName("java.lang.String").getClassLoader();
            System.out.println(classLoader);
            //方式2:获取当前线程上下文的ClassLoader
            ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
            System.out.println(contextClassLoader);
            //方式3:获取系统的ClassLoader
            ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
            System.out.println(systemClassLoader);
            //方式4:获取调用者的ClassLoader
//            DriverManager.getCallerClassLoader();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

双亲委派机制

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

双亲委派机制

优势

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

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

类的主动使用于被动使用
在JVM中标识两个class对象是否为同一个类存在两个必要条件

• 类的完整类名必须一,也就是全限定名必须一致
• 加载这个类的ClassLoader(指ClassLoader实例对象) 必须相同

主动使用的七种情况

• 创建类的实例
• 访问某个类或者接口的静态常量,或者对该静态常量变量赋值
• 调用类的静态方法
• 反射 (Class.forName("cn.icanci.dao.UserDao"))
• 初始化一个类的子类
• Java虚拟机启动的时候被标为启动类的类
• JDK7开始使用的动态语言支持 java.lang.invoke.MethodHandle 实例的解析结果 REF_getStatic,REF_putStatic, ,REF_invokeStatic句柄对应的类没有初始化,则初始化

除了以上7种,其他使用Java类的方式都看作是类的被使用

7. 运行时数据区内部结构

JVM内存布局规定了Java在运行过程中内存申请,分配,管理的策略,保证了JVM的高效稳定运行,不同的JVM对于内存的划分方式和管理机制存在着部分差异.

内部结构

每个线程:独立包括应用程序计数器.栈.本地栈
线程间共享:堆,堆外内存(永生代或元空间,代码缓存)

JVM线程说明

• JVM允许一个应用由多个线程并行的执行
• 在HotSpot JVM里面,每个线程都是与本地线程直接映射
• 当一个Java线程准备好执行之后,此时一个操作系统的本地线程也同时创建,Java程序终止之后,本地线程也会回收
• 操作系统负责所有线程的安排调度到任何一个可用的CPU上,一旦本地线程初始化成功,他就会调用Java线程中的run()方法

JVM系统线程

如果使用 jconsole 或者是其他的调试工具,都可以看到后台由很多线程在运行

• 虚拟机线程:这种线程的操作是需要JVM达到安全点才会出现。这些操作必须在不同的线程中发生的原因是他们都需要JVM达到安全点，这样堆才不会变化。这种线程的执行类型包括”stop-the-world"的垃圾收集，线程栈收集，线程挂起以及偏向锁撤销。
• 周期任务线程:这种线程是时间周期事件的体现(比如中断)，他们一-般用于周期性操作的调度执行。
• GC线程:这种线程对在JVM里不同种类的垃圾收集行为提供了支持。➢编译线程:这种线程在运行时会将字节码编译成到本地代码。
• 信号调度线程:这种线程接收信号并发送给JVM，在它内部通过调用适当的方法进行处理。

8. PC寄存器

JVM中的程序计数寄存器(Program Counter Register) 中， Register 的命名源于CPU的寄存器，寄存器存储指令相关的现场信息。CPU只 有把数据装载到寄存器才能够运行。这里，并非是广义上所指的物理寄存器，或许将其翻译为PC计数器(或指令计数器)会更加贴切(也称为程序钩子)，并且也不容易引起- - 些不必要的误会。JVM中的PC寄存器是对物理PC寄存器的一种抽象模拟。

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

PC寄存器

实例

面试题

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

• 以为你CPU在不停的切换各个线程,这个时候切换到哪儿,需要知道应该继续从哪儿开始
• JVM的字节码解释器就需要通过改变PC寄存器的值来明确下一条应该执行什么样的字节码指令

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

• 我们都知道所谓的多线程在一个特定的时间段内只会执行其中某一个线程的方法，CPU会不停地做任务切换，这样必然导致经常中断或恢复，如何保证分毫无差呢?为了能够准确地记录各个线程正在执行的当前字节码指令地址，最好的办法自然是为每-一个线程都分配一个PC寄存器，这样- *来各个线程之间便可以进行独立计算，从而不会出现相互干扰的情况。
  由于CPU时间片轮限制，众多线程在并发执行过程中，任何一个确定的时刻，一个处理器或者多核处理器中的一个内核，只会执行某个线程中的一条指令。
  这样必然导致经常中断或恢复，如何保证分毫无差呢?每个线程在创建后，都会产生自己的程序计数器和栈帧，程序计数器在各个线程之间互不影响。

8. 虚拟机栈的主要特点

虚拟机栈出现的背景

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

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

栈是运行时的单位,堆是存储的单位

• 栈解决程序的运行问题,程序在哪儿执行,或者说如歌处理数据,堆解决的是数据存储的问题,数据怎么放,放哪儿

基本内容

• 每个线程在创建的时候都会创建一个虚拟机栈,其内部保存一个个的栈帧,对应一次次的方法调用
• 是线程私有的
• 生命周期 和线程一致
• 作用:主管Java程序的运行,它保存方法的局部变量,部分结果,并参与方法的调用和返回

优点

• 栈是一种快速有效的分配存储方式,访问速度仅次于程序计数器
• JVM直接对Java的操作只有两个

1. 每个方法执行 伴随着入栈,压栈
2. 执行而结束之后的出栈操作

• 对于栈来说不存在垃圾回收问题

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

Java虚拟机规范允许Java栈的大小是动态的或者是固定不变的。
如果采用固定大小的Java虚拟机栈，那每一个线程的Java虚拟机栈容量

可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过Java虚拟机栈允许的最大容量，Java虚拟机将会抛出一个StackoverflowError异常。

如果Java虚拟机栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈,那Java虚拟机将会抛出一个OutofMemoryError异常。

设置栈内存大小

• 可以设置参谁 -Xss 来设置线程的最大栈空间,站栈的大小直接决定了函数调用的深度

栈中存储什么?

• 每个线程都有自己的栈,栈中的数据都是以 栈帧 的格式存在
• 在这个线程上正在执行的每个方法各自对应一个栈帧
• 栈帧是一个内存区块,是一个数据集,维系着方法执行过程中的各种数据信息

运行原理

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

在一条活动线程中，-一个时间点上，只会有一个活动的栈帧。即只有当前正在执行的方法的栈帧(栈顶栈帧)是有效的，这个栈帧被称为当前栈帧(Current Frame) ，与当前栈帧相对应的方法就是当前方法(Current (Method)，定义这个方法的类就是当前类(Current Class) 。执行引擎运行的所有字节码指令只针对当前栈帧进行操作。

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

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

如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着，虚拟机会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧。.

Java方法有两种返印函数的方式，-种是正常的函数返回，使用return指令;另外一种是抛出异常。不管使用哪种方式，都会导致栈帧被弹出。

栈帧的内存结构

• 局部变量表
• 操作数栈 [或者表达式栈]
• 动态连接 [或指向运行时常量池的方法引用]
• 方法返回地址[或方法正常退出或者异常退出的定义]
• 一些附加信息

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

定义为一-个数字数组，主要用于存储方法参数和定义在方法体内的局部变量这些数据类型包括各类基本数据类型、对象引用(reference) ，以及returnAddress类型。

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

局部变量表所需的容量大小是在编译期确定下来的，并保存在方法的Code属性的maximum local variables数据项中。 在方法运行期间是不会改变局部变量表的大小的。

方法嵌套调用的次数由栈的大小决定。-一般来说，栈越大，方法嵌套调用次数越多。对一个函数而言，它的参数和局部变量越多，使得局部变量表膨胀，它的栈帧就越大，以满足方法调用所需传递的信息增大的需求。进而函数调用就会占用更多的栈空间，导致其嵌套调用次数就会减少。

局部变量表中的变量只在当前方法调用中有效。在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。当方法调用结束后，随着方法栈帧的销毁，局部变量表也会随之销毁。

关于Solt的理解
参数值的存放总是在局部变量数组的index=0开始，到数组长度- 1的索引结束。

局部变量表，最基本的存储单元是Slot (变量植)

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

在局部变量表里，32位以内的类型只占用一一个slot (包括returnAddress类型)，64位的类型( long和double)占用两个slot。

byte 、short 、char 在存储前被转换为int，boolean也被转换为int，0表示false，非0表示true。

long 和double 则占据两个Slot。

栈帧中的局部变量表的槽位是可以重用的

静态变量和局部变量的对比和小结

数据类型 基本数据类型 引用数据类型
成员变量:类变量实例变量 都经过默认初始化赋值
局部变量 :在使用之前必须赋值

补充说明

• 在栈帧中,与性能调优关系最为密切的就是前面的局部变量表,在方法执行的时候,虚拟机使用局部变量表完成方法的传递
• 局部变量表中的变量也是重要的垃圾回收根节点,只要被局部变量表直接或间接引用的对象都不会被回收

操作数栈的特点

每一个独立的栈帧中除了包含局部变量表以外，还包含一个后进先出(Last-In-First-Out)的操作数栈，也可以称之为表达式栈(Expression Stack) 。

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

某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈。使用它们后再把结果压入栈。比如:执行复制、交换、求和等操作

栈

操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。

操作数栈就森体面4报行引警的五个工作区，当一个方法刚开始执行的时候，一个新的栈顿也会随之被创建出来，这个方法的操作数栈是空的。

每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译期就定义好了，保存在方法的Code属性中，为max stack的值。

栈中的任何一个元素都是可以任意的Java数据类型。
32bit的类型占用一个栈单位深度 64bit的类型占用两个栈单位深度.

操作数栈并非采用访问索引的方式来进行数据访问的，而是只能通过标准的入栈(push) 和出栈(pop) 操作来完成一次 数据访问。.

如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中，并更新PC寄存器中下一-条需要执行的字节码指令。

操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译器期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证。

另外，我们说Java虚拟机的解释引擎是基于栈的执行引擎，其中的栈指的就是操数栈。

栈顶缓存技术

前面提过，基于伐式架构的虛拟机所使用的零地址:指令更加紧凑，但完成一项操作的时候必然需要使用更多的入栈和出栈指令，这同时也就意味着将需要更多的指令分派( instruction dispatch) 次数和内存读/写次数。

由于操作数是存储在内存中的，因此频繁地执行内存读/写操作必然会影响执行速度。为了解决这个问题，HotSpot JVM的设计者们提出了栈顶缓存(ToS，Top-of-Stack Cashing) 技术，将栈顶元素全部缓存在物理CPU的寄存器中，以此降低对内存的读/写次数，提升执行引擎的执行效率。

动态链接

每一个栈帧内部都包含一个指向运行时常量池中该栈帧所属方法的引用。包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接(Dynamic Linking) 。比如: invokedynamic指令

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

为什么需要常量池?
提供一些符号和常量,便于指令的识别

方法调用

在JVM中，将符号引用转换为调用方法的直接引用与方法的绑定机制相关T

静态链接:

当一个字节码文件被装载进JVM内部时，如果被调用的目标方法在编译期可知,且运行期保持不变时。这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态链接。

动态链接:

如果被调用的方法在编译期无法被确定下来，也就是说，只能够在程序运行期将调用方法的符号引用转换为直接引用，由于这种引用转换过程具备动态性，因此也就被称之为动态链接。

对应的方法的绑定机制为:早期绑定(Early Binding)和晚期绑定(Late Binding) 。绑定是一个字段、方法或者类在符号引用被替换为直接引用的过程，这仅仅发生一次

早期绑定:

早期绑定就是指被调用的目标方法如果在编译期可知，且运行期保持不变时,即可将这个方法与所属的类型进行绑定，这样一来，由于明确了被调用的目标方法究竟是哪-一个，因此也就可以使用静态链接的方式将符号引用转换为直接引用。

晚期绑定:

如果被调用的方法在编译期无法被确定下来，只能够在程序运行期根据实际的类型绑定相关的方法，这种绑定方式也就被称之为晚期绑定。

随着高级语言的横空出世，类似于Java一样的基于面向对象的编程语言如今越来越多，尽管这类编程语言在语法风格上存在一定的差别，但是它们彼此之间始终保持着-一个共性，那就是都支持封装、继承和多态等面向对象特性，既然这一类的编程语言具备多态特性，那么自然也就具备早期绑定和晚期绑定两种绑定方式。

Java中任何一个普通的方法其实都具备虚函数的特征，它们相当于C++语言中的虚函数(C+ +中则需要使用关键字virtual来显式定义)。如果在Java程序中不希望某个方法拥有虚丽数的特征时，则可以使用关键字final来标记这个方法。

4种方法调用指令区别虚方法和非虚方法

非虚方法

• 如果方法在编译器就已经确定了具体的版本,这个版本在运行时期是不可变,
• 静态方法 私有方法 final 方法 实例构造器 父类方法都是非虚方法
• 其他方法称为虚方法
• 子类对象多态使用的前提:类的继承关系 方法的重写

虚拟机中提供了以下几条方法调用指令:

• 普通调用指令:

1. invokestatic: 调用静态方法，解析阶段确定唯一 方法版本
2. invokespesiai: 调用<init>方法、 私有及父类方法，解析阶段确定唯一方法版本
3. invokevirtlal: 气调用所有虚方法
4. invokeinterface:调用接口方法

• 动态调用指令:

5. invokedynamic: 动态解析出需要调用的方法，然后执行
   前四条指令固化在虚拟机内部，方法的调用执行不可人为千预，而invokedynamic指令则支持由用户确定方法版本。其中invokestatic指令和invokespecial指令调用的方法称为非虚方法，其余的(final修饰的除外)称为虚方法。

动态编译
JVM字节码指令集一直比较稳定，一直到Java7中才增加了一个invokedynamic指令，这是Java为了实现「动态类型语言」支持而做的一种改进。

但是在Java7中并没有提供直接生成i nvokedynamic指令的方法，需要借助ASM这种底层字节码工具来产生invokedynamic指令。直到Java 8的Lambda表达式的出现，invokedynamic指 令的生成，在Java中才有了直接的生成方式。

Java7中增加的动态语言类型支持的本质是对Java虚拟机规范的修改，而不是对Java语言规则的修改，这一块相对来讲比较复杂，增加了虚拟机中的方法调用，最直接的受益者就是运行在Java平台的动态语言的编译器。

动态类型语言和静态类型语言
动态类型语言和静态类型语言两者的区别就在于对类型的检查是在编译期还是在运行期，满足前者就是静态类型语言，反之是动态类型语言。

说的再直白-一点就是，静态类型语言是判断变量自身的类型信息;动态类型语言是判断变量值的类型信息，变量没有类型信息，变量值才有类型信息，这是动态语言的一个重要特征。

Java语言中方法重写的本质:
1.找到操作数栈顶的第一个元素所执行的对象的实际类型，记作C。

2.如果在类型C中找到与常量中的描述符合简单名称都相符的方法，则进行访问权限校验，如果通过则返回这个方法的直接引用，查找过程结束;如果不通过，则返回java. lang . IllegalAccessError异常。

3.否则，按照继承关系从下往上依次对C的各个父类进行第2步的搜索和验证过程。
4.如果始终没有找到合适的方法，则抛出java. lang . AbstractMethodError异常。

IllegalAccessError介绍:

程序试图访问或修改-一个属性或调用一个方法，这个属性或方法，你没有权限访问。一般的，这个会引起编译器异常。这个错误如果发生在运行时，就说明一个类发生了不兼容的改变。

虚方法表
在面向对象的编程中，会很频繁的使用到动态分派，如果在每次动态分派的过程中都要重新在类的方法元数据中搜索合适的目标的话就可能影响到执行效率。因此，为了提高性能，TJVM采用在类的方法区建立-一个虚方法表(virtual method table) (非虚方法不会出现在表中)来实现。使用索引表来代替查找。

每个类中都有一一个虚方法表，表中存放着各个方法的实际入口。
那么虚方法表什么时候被创建?

虚方法表会在类加载的链接阶段被创建并开始初始化，类的变量初始值准备完成之后，JVM会把该类的方法表也初始化完毕。

方法返回地址

存放调用该方法的pc寄存器的值。
一个方法的结束，有两种方式:

1. 正常执行完成
2. 出现未处理的异常，非正常退出

无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置。方法正常退出时，调用者的pc计数器的值作为返回地址，即调用该方法的指令的下一-条指令的地址。而通过异常退出的，返回地址是要通过异常表来确定，栈帧中- -般不会保存这部分信息。

正常完成出口和异常完成出口的区别就是:通过异常完成出口退出的不会给它的上层调用者产生任何的返回值.

当一个方法开始执行后，只有两种方式可以退出这个方法:

1 执行引擎遇到任意-一个方法返回的字节码指令(return)，会有返回值传递给上层的方法调用者，简称正常完成出口;

一个方法在正常调用完成之后究竟需要使用哪一个返回指令还需要根据方法返回值的实际数据类型而定。

在字节码指令中，返回指令包含ireturn (当返回值是boolean、byte、char.short和int类型时使用)、lreturn、 freturn、 dreturn以及areturn，另外还有一个return指令供声明为void的方法、实例初始化方法、类和接口的初始化方法使用。

2 在方法执行的过程中遇到了异常(Exception)，并且这个异常没有在方法内进行处理，也就是R要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出。简称异常完成出口。

方法执行过程中抛出异常时的异常处理，存储在-一个异常处理表，方便在发生异常的时候找到处理异常的代码。

虚拟机栈的5道面试题

举例栈溢出的情况?(StackOverflowError)

• 通过调整 -Xss 设置栈的大小

调整栈大小,就能保证不出现栈溢出吗?

• 不能 理论上,在一定时间内栈溢出的可能性会较低

配的栈内存是越大越好吗?

• 并不是.会影响其他空间的大小,

垃圾回收是否涉及到虚拟机栈?

• 不会 因为垃圾回收不存在GC

方法自定义的局部变量是否线程安全?

• 具体问题具体分析 比如局部变量中的 StringBuilder(线程安全)和StringBuffer(线程不安全)
• 如果只有一个线程操作此数据,那么就是线程安全的(内部产生内部结束,是安全的)
• 如果不是只有一个线程访问,那么内部数据不是线程安全的,那么就有可能发生线程安全问题

9. 本地方法接口

什么是本地方法

简单地讲，一个Native Method就是-一个Java调用非Java代码的接口。一个Native Method是这样-一个Java方法:该方法的实现由非Java语言实现，比如C。这个特征并非Java所特有，很多其它的编程语言都有这- -机制，比如在C+ +中，你可以用extern"C"告知C++编译器去调用-一个C的函数。

"A native method is a Java method whose implementation isprovided by non-java code."

在定义一个native method时， 并不提供实现体(有些像定义一个Java interface)，因为其实现体是由非java语言在外面实现的。

本地接口的作用是融合不同的编程语言为Java所用，它的初衷是融合C/C++程序。

为什么需要使用Native Method

Java使用起来非常方便，然而有些层次的任务用Java实现起来不容易，或者我们对程序的效率很在意时，问题就来了。

与Java环境外交互:

有时Java应用需要与Java外面的环境交互，这是本地方法存在的主要原因。你可以想想Java需要与一些底层系统，如操作系统或某些硬件交换信息时的情况。本地方法正是这样一种交流机制:它为我们提供了一个非常简洁的接口，而且我们无需去了解Java应用之外的繁琐的细节。

与操作系统交互:

JVM支持着Java语言本身和运行时库，它是Java程序赖以生存的平台，它由一个解释器(解释字节码)和一些连接到本地代码的库组成。然而不管怎样，它毕竟不是一个完整的系统，它经常依赖于- -些底层系统的支持。这些底层系统常常是强大的操作系统。通过使用本地方法，我们得以用Java实现了jre的与底层系统的交互，甚至JVM的一一些部分就是用C写的。还有，如果我们要使用一些Java语言本身没有提供封装的操作系统的特性时，我们也需要使用本地方法。

Sun's Java .

Sun的解释器是用C实现的，这使得它能像一些普通的C-样与外部交互。jre大部分 是用Java实现的，它也通过一些本地方法与外界交互。例如:类java. lang. Thread的setPriority() 方法是用Java实现的，但是它实现调用的是该类里的本地方法setPriority0()。这个本地方法是用c实现的，并被植入JVM内部，在windows 95的平台上，这个本地方法最终将调用win32 SetPriority() API。 这是一个本地方法的具体实现由JVM直接提供，更多的情况是本地方法由外部的动态链接库(external dynamic link library) 提供，然后被JVM调用。

现状

目前该方法使用的越来越少了，除非是与硬件有关的应用，比如通过
Java程序驱动打印机或者Java系统管理生产设备，在企业级应用中已经比较少见。因为现在的异构领域间的通信很发达，比如可以使用Socket通信，也可以使用web Service等等,不多做介绍

本地方法栈
Java虚拟机栈用于管理Java方法的调用，而本地方法栈用于管理本地方法的调用。

本地方法栈，也是线程私有的。.

允许被实现成固定或者是可动态扩展的内存大小。(在内存溢出方面是相同的)

如果线程请求分配的栈容量超过本地方法栈允许的最大容量，Java虚拟机将会抛出一个StackoverflowError 异常。

如果本地方法栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的内存， 或者在创建新的线程时没有足够的内存去创建对应的本地方法栈，那么Java虚拟机将会抛出一个OutOfMemoryError 异常。本地方法是使用C语言实现的。

它的具体做法是Native Method Stack中 登记native方法，在Execution Engine 执行时加载本地方法库。

当某个线程调用一个本地方法时，它就进入了一个全新的并且不再受虚拟机限制的世界。它和虚拟机拥有同样的权限。

本地方法可以通过本地方法接0来访问虚拟机内部的运行时数据区。➢它甚至可以直接使用本地处理器中的寄存器➢直接从本地内存的堆中分配任意数量的内存。

并不是所有的JVM都支持本地方法。因为Java虚拟机规范并没有明确要求本地方法栈的使用语言、具体实现方式、数据结构等。如果JVM产品不打算支持native方法，也可以无需实现本地方法栈。

在Hotspot JVM中，直接将本地方法栈和虚拟机栈合二为一。