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

XinYa
230 阅读35分钟

内存与垃圾回收

1 JVM与Java体系结构

1.1 简介

JVM的位置

170ec702fcca6b37.png

Java代码执行顺序

java程序-->（javac编译）-->字节码文件-->（JVM解释执行）-->操作系统（Win，Linux，Mac JVM）

JVM的整体结构(会画)

170ec6cbb7b888f5.png

JVM虚拟机特点

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

栈的指令集架构和寄存器的指令集架构

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

  • 栈：跨平台性、指令集小、指令多；执行性比寄存器差
  • 寄存器：指令少, 速度快。但是与硬件耦合度比较高,可移植性差

1.2 JVM生命周期

启动

通过引导类加载器（bootstrap class loader）创建一个初始类（initial class）来完成的，这个类是由虚拟机的具体实现指定的.

执行

  • 一个运行中的java虚拟机有着一个清晰的任务：执行Java程序；
  • 程序开始执行的时候他才运行，程序结束时他就停止；
  • 执行一个所谓的Java程序的时候，真真正正在执行的是一个叫做Java虚拟机的进程。

退出

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

2 类的加载子系统

JVM架构图

170ec7cd31581d15.png

2.1 类加载子系统的作用

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

2.2 类加载子系统的过程

170ec7daeca85a52.png

2.2.1 加载

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

2.2.2 链接

2.2.2.1 验证
  • 目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求，保证被加载类的正确性，不会危害虚拟机自身安全。
  • 主要包括四种验证，文件格式验证，源数据验证，字节码验证，符号引用验证。
2.2.2.2 准备
  • 为类变量分配内存并且设置该类变量的默认初始值，即零值；
  • 这里不包含用final修饰的sttic，因为final在编译的时候就会分配了，准备阶段会显式初始化；
  • 这里不会为实例变量分配初始化，类变量会分配在方法区中，而实例变量是会随着对象一起分配到java堆中。
2.2.2.3 解析
  • 将常量池内的符号引用转换为直接引用的过程。
  • 事实上，解析操作网晚会伴随着jvm在执行完初始化之后再执行
  • 符号引用就是一组符号来描述所引用的目标。符号应用的字面量形式明确定义在《java虚拟机规范》的class文件格式中。直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄
  • 解析动作主要针对类或接口、字段、类方法、接口方法、方法类型等。对应常量池中的CONSTANT_Class_info/CONSTANT_Fieldref_info、CONSTANT_Methodref_info等

2.2.3 初始化

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

3 类的加载器分类

  • JVM支持两种类型的加载器，分别为引导类加载器（BootStrap ClassLoader）和自定义类加载器（User-Defined ClassLoader）
  • 从概念上来讲，自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器，但是java虚拟机规范却没有这么定义，而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器。
  • 无论类加载器的类型如何划分，在程序中我们最常见的类加载器始终只有三个，如下所示：

170ec88cffd157f0.png

3.1 自定义类与核心类库的加载器

  • 对于用户自定义类来说：使用系统类加载器AppClassLoader进行加载
  • java核心类库都是使用引导类加载器BootStrapClassLoader加载的
/**
 * ClassLoader加载
 */
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@610455d6

        //获取其上层 获取不到引导类加载器
        ClassLoader bootStrapClassLoader = extClassLoader.getParent();
        System.out.println(bootStrapClassLoader);//null

        //对于用户自定义类来说：使用系统类加载器进行加载
        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

    }
}

3.2 虚拟机自带的加载器

3.2.1 启动类加载器（引导类加载器，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等开头的类

3.2.2 拓展类加载器（Extension ClassLoader）

  • java语言编写 ，由sun.misc.Launcher$ExtClassLoader实现。
  • 派生于ClassLoader类
  • 父类加载器为启动类加载器
  • 从java.ext.dirs系统属性所指定的目录中加载类库，或从JDK的安装目录的jre/lib/ext子目录（扩展目录）下加载类库。如果用户创建的JAR放在此目录下，也会由拓展类加载器自动加载

3.2.3 应用程序类加载器（系统类加载器，AppClassLoader）

  • java语言编写， 由sun.misc.Launcher$AppClassLoader实现。
  • 派生于ClassLoader类
  • 父类加载器为拓展类加载器
  • 它负责加载环境变量classpath或系统属性 java.class.path指定路径下的类库
  • 该类加载器是程序中默认的类加载器，一般来说，java应用的类都是由它来完成加载 通过ClassLoader#getSystemClassLoader()方法可以获取到该类加载器

3.2.4 代码演示

/**
 * 虚拟机自带加载器
 */
public class ClassLoaderTest1 {
    public static void main(String[] args) {
        System.out.println("********启动类加载器*********");
        URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();
        //获取BootStrapClassLoader能够加载的api路径
        for (URL e:urls){
            System.out.println(e.toExternalForm());
        }

        //从上面的路径中随意选择一个类 看看他的类加载器是什么
        //Provider位于 /jdk1.8.0_171.jdk/Contents/Home/jre/lib/jsse.jar 下，引导类加载器加载它
        ClassLoader classLoader = Provider.class.getClassLoader();
        System.out.println(classLoader);//null

        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@4dc63996
    }
}

3.3 用户自定义类加载器

在Java的日常应用程序开发中,类的加载几乎是由上述3种类加载器相互配合执行的，在必要时,我们还可以自定义类加载器,来定制类的加载方式。

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

  • 隔离加载类
  • 修改类加载的方式
  • 扩展加载源
  • 防止源码泄露

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

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

4 ClassLoader的常用方法及获取方法

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

方法名称描述
getParent（）返回该类加载器的超类加载器
loadClass（String name）加载名称为name的类，返回结果为java.lang.Class类的实例
findClass（String name）查找名称为name的类，返回结果为java.lang.Class类的实例
findLoadedClass（String name）查找名称为name的已经被加载过的类，返回结果为java.lang.Class类的实例
defineClass（String name，byte[] b,int off,int len）把字节数组b中的内容转换为一个Java类 ，返回结果为java.lang.Class类的实例
resolveClass（Class<?> c）连接指定的一个java类

拓展类加载器和系统类加载器间接继承于ClassLoader抽象类

170ec8a4eaae0b43.png

获取ClassLoader的途径

170ec8b36f5d4187.png

170ec8b6c081f466.png

5 双亲委派机制

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

5.1 双亲委派机制加载原理

170ec8cbbe16af0c.png

5.2 双亲委派机制的优势

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

5.3 沙箱安全机制

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

6 其他

  • 在jvm中表示两个class对象是否为同一个类存在的两个必要条件
    • 类的完整类名必须一致，包括包名
    • 加载这个类的ClassLoader（指ClassLoader实例对象）必须相同
  • 换句话说，在jvm中，即使这两个类对象（class对象）来源同一个Class文件，被同一个虚拟机所加载，但只要加载它们的ClassLoader实例对象不同，那么这两个类对象也是不相等的.

6.1 对类加载器的引用

JVM必须知道一个类型是有启动类加载器加载的还是由用户类加载器加载的。如果一个类型由用户类加载器加载的，那么jvm会将这个类加载器的一个引用作为类型信息的会议部分保存在方法区中。当解析一个类型到另一个类型的引用的时候，JVM需要保证两个类型的加载器是相同的。

6.2 类的主动使用和被动使用

主动使用，分为七种情况

  • 创建类的实例
  • 访问某各类或接口的静态变量，或者对静态变量赋值
  • 调用类的静态方法
  • 反射 比如Class.forName(com.dsh.jvm.xxx)
  • 初始化一个类的子类
  • java虚拟机启动时被标明为启动类的类
  • JDK 7 开始提供的动态语言支持：java.lang.invoke.MethodHandle实例的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic句柄对应的类没有初始化，则初始化

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

7 运行时数据区

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

7.1.1 作用

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

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

7.1.2 面试问题

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

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

2.PC寄存器为什么会设定为线程私有

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

7.1.3 CPU时间片

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

  • 并行：同一时间多个线程同时执行；
  • 并发：一个核快速切换多个线程，让它们依次执行，看起来像并行，实际上是并发

7.2 虚拟机栈

7.2.1 概述

背景

由于跨平台性的设计，java的指令都是根据栈来设计的。不同平台CPU架构不同，所以不能设计为基于寄存器的。 优点是跨平台，指令集小，编译器容易实现，缺点是性能下降，实现同样的功能需要更多的指令。

内存中的堆与栈

  • 栈是运行时的单位，而堆是存储的单位 即：栈解决程序的运行问题，即程序如何执行，或者说如何处理数据。堆解决的是数据存储的问题，即数据怎么放、放在哪儿。
  • 一般来讲，对象主要都是放在堆空间的，是运行时数据区比较大的一块
  • 栈空间存放 基本数据类型的局部变量，以及引用数据类型的对象的引用

虚拟机栈是什么

  • java虚拟机栈（Java Virtual Machine Stack），早期也叫Java栈。每个线程在创建时都会创建一个虚拟机栈，其内部保存一个个的栈帧（Stack Frame），对应一个个的java方法调用。它是线程私有的
  • 生命周期和线程是一致的
  • 作用：主管java程序的运行，它保存方法的局部变量（8种基本数据类型、对象的引用地址）、部分结果，并参与方法的调用和返回。
    • 局部变量：相对于成员变量（或属性）
    • 基本数据变量： 相对于引用类型变量（类，数组，接口）

栈的特点

  • 栈是一种快速有效的分配存储方式，访问速度仅次于PC寄存器（程序计数器）
  • JVM直接对java栈的操作只有两个
    • 每个方法执行，伴随着进栈（入栈，压栈）
    • 执行结束后的出栈工作
  • 对于栈来说不存在垃圾回收问题

栈中可能出现的异常

java虚拟机规范允许Java栈的大小是动态的或者是固定不变的 如果采用固定大小的Java虚拟机栈，那每一个线程的java虚拟机栈容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过java虚拟机栈允许的最大容量，java虚拟机将会抛出一个 StackOverFlowError异常

/**
 * 演示栈中的异常
 */
public class StackErrorTest {
    public static void main(String[] args) {
        main(args);
    }
}

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

7.2.2 栈的存储单位与运行原理

栈中存储的内容

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

栈运行原理

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

栈帧的内部结构

  • 局部变量表（Local Variables）
  • 操作数栈（Operand Stack）(或表达式栈)
  • 动态链接（Dynamic Linking）(或执行运行时常量池的方法引用)
  • 方法返回地址（Return Adress）（或方法正常退出或者异常退出的定义）
  • 一些附加信息

170ecafe0fab0cb2.png

7.2.3 局部变量表

概述

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

变量槽slot的理解与演示

  • 参数值的存放总是在局部变量数组的index0开始，到数组长度-1的索引结束
  • 局部变量表，最基本的存储单元是Slot(变量槽)
  • 局部变量表中存放编译期可知的各种基本数据类型（8种），引用类型（reference），returnAddress类型的变量。
  • 在局部变量表里，32位以内的类型只占用一个slot（包括returnAddress类型），64位的类型（long和double）占用两个slot。
    • byte、short、char、float在存储前被转换为int，boolean也被转换为int，0表示false，非0表示true；
    • long和double则占据两个slot。
  • JVM会为局部变量表中的每一个slot都分配一个访问索引，通过这个索引即可成功访问到局部变量表中指定的局部变量值
  • 当一个实例方法被调用的时候，它的方法参数和方法体内部定义的局部变量将会按照顺序被复制到局部变量表中的每一个slot上
  • 如果需要访问局部变量表中一个64bit的局部变量值时，只需要使用签一个索引即可。（比如：访问long或者double类型变量）
  • 如果当前帧是由构造方法或者实例方法创建的，那么该对象引用this将会存放在index为0的slot处,其余的参数按照参数表顺序排列。

slot的重复利用

栈帧中的局部变量表中的槽位是可以重复利用的，如果一个局部变量过了其作用域，那么在其作用域之后申明的新的局部变量就很有可能会复用过期局部变量的槽位，从而达到节省资源的目的。

private void test2() {
        int a = 0;
        {
            int b = 0;
            b = a+1;
        }
        //变量c使用之前以及经销毁的变量b占据的slot位置
        int c = a+1;
    }

静态变量与局部变量的对比

  • 按照数据类型分：
    • ①基本数据类型;
    • ②引用数据类型；
  • 按照在类中声明的位置分：
    • ①成员变量：在使用前，都经历过默认初始化赋值
      • static修饰：类变量：类加载linking的准备阶段给类变量默认赋值——>初始化阶段给类变量显式赋值即静态代码块赋值；
      • 不被static修饰：实例变量：随着对象的创建，会在堆空间分配实例变量空间，并进行默认赋值
    • ②局部变量：在使用前，必须要进行显式赋值的！否则，编译不通过 补充：
  • 在栈帧中，与性能调优关系最为密切的部分就是局部变量表。在方法执行时，虚拟机使用局部变量表完成方法的传递
  • 局部变量表中的变量也是重要的垃圾回收根节点，只要被局部变量表中直接或间接引用的对象都不会被回收

7.2.4 操作数栈

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

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

7.2.5 动态链接

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

170ecb779318dd20.png

为什么需要常量池

常量池的作用，就是为了提供一些符号和常量，便于指令的识别。

方法的调用

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

静态链接与动态链接

  • 静态链接: 当一个 字节码文件被装载进JVM内部时，如果被调用的目标方法在编译期可知，且运行期保持不变时。这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态链接。
  • 动态链接: 如果被调用的方法在编译期无法被确定下来，也就是说，只能够在程序运行期将调用方法的符号引用转换为直接引用，由于这种引用转换过程具备动态性，因此也就被称之为动态链接。

虚拟机中提供以下几种方法调用指令

普通调用指令

  • 1.invokestatic：调用静态方法，解析阶段确定唯一方法版本；
  • 2.invokespecial:调用方法、私有及弗雷方法，解析阶段确定唯一方法版本；
  • 3.invokevirtual调用所有虚方法；
  • 4.invokeinterface：调用接口方法； 动态调用指令：
  • 5.invokedynamic：动态解析出需要调用的方法，然后执行 . 前四条指令固化在虚拟机内部，方法的调用执行不可人为干预，而invokedynamic指令则支持由用户确定方法版本。其中invokestatic指令和invokespecial指令调用的方法称为非虚方法，其余的（final修饰的除外）称为虚方法。

7.3 本地方法栈

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

7.4 本地方法接口

7.4.1 本地方法

简单来讲，一个Native Method就是一个java调用非java代码的接口，一个Native Method 是这样一个java方法：该方法的实现由非Java语言实现，比如C。这个特征并非java特有，很多其他的编程语言都有这一机制，比如在C++ 中，你可以用extern “C” 告知C++ 编译器去调用一个C的函数。 在定义一个native method时，并不提供实现体（有些像定义一个Java interface），因为其实现体是由非java语言在外面实现的。 本地接口的作用是融合不同的编程语言为java所用，它的初衷是融合C/C++程序。 标识符native可以与其他所有的java标识符连用，但是abstract除外。

/**
 * 本地方法
 */
public  class IHaveNatives {

    //abstract 没有方法体
    public abstract void abstractMethod(int x);

    //native 和 abstract不能共存，native是有方法体的，由C语言来实现
    public native void Native1(int x);

    native static public long Native2();

    native synchronized private float Native3(Object o);

    native void Native4(int[] array) throws Exception;

}

为什么要使用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 SetProority（）API。这是一个本地方法的具体实现由JVM直接提供，更多的情况是本地方法由外部的动态链接库（external dynamic link library）提供，然后被JVM调用。

现状

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

8 堆

8.1 核心概述

一个进程对应一个jvm实例，一个运行时数据区，又包含多个线程，这些线程共享了方法区和堆，每个线程包含了程序计数器、本地方法栈和虚拟机栈。

  • 一个jvm实例只存在一个堆内存，堆也是java内存管理的核心区域
  • Java堆区在JVM启动的时候即被创建，其空间大小也就确定了。是JVM管理的最大一块内存空间（堆内存的大小是可以调节的）
  • 《Java虚拟机规范》规定，堆可以处于物理上不连续的内存空间中，但在逻辑上它应该被视为连续的
  • 所有的线程共享java堆，在这里还可以划分线程私有的缓冲区（TLAB:Thread Local Allocation Buffer）.（面试问题：堆空间一定是所有线程共享的么？不是，TLAB线程在堆中独有的）
  • 《Java虚拟机规范》中对java堆的描述是：所有的对象实例以及数组都应当在运行时分配在堆上。
    • 从实际使用的角度看，“几乎”所有的对象的实例都在这里分配内存 （‘几乎’是因为可能存储在栈上）
  • 数组或对象永远不会存储在栈上，因为栈帧中保存引用，这个引用指向对象或者数组在堆中的位置
  • 在方法结束后，堆中的对象不会马上被移除，仅仅在垃圾收集的时候才会被移除
  • 堆，是GC(Garbage Collection，垃圾收集器)执行垃圾回收的重点区域

堆得细分内存结构

  • JDK 7以前： 新生区+养老区+永久区
    • Young Generation Space：又被分为Eden区和Survior区 ==Young/New==
    • Tenure generation Space： ==Old/Tenure==
    • Permanent Space： ==Perm==
  • JDK 8以后： 新生区+养老区+元空间
    • Young Generation Space：又被分为Eden区和Survior区 ==Young/New==
    • Tenure generation Space： ==Old/Tenure==
    • Meta Space： ==Meta==

8.2 设置堆内存大小与OOM

  • Java堆区用于存储java对象实例，堆的大小在jvm启动时就已经设定好了，可以通过 "-Xmx"和 "-Xms"来进行设置
    • -Xms 用于表示堆的起始内存，等价于 -XX:InitialHeapSize
      • -Xms 用来设置堆空间（年轻代+老年代）的初始内存大小
        • -X 是jvm的运行参数
        • ms 是memory start
    • -Xmx 用于设置堆的最大内存，等价于 -XX:MaxHeapSize
  • 一旦堆区中的内存大小超过 -Xmx所指定的最大内存时，将会抛出OOM异常
  • 通常会将-Xms和-Xmx两个参数配置相同的值，其目的就是为了能够在java垃圾回收机制清理完堆区后不需要重新分隔计算堆区的大小，从而提高性能
  • 默认情况下，初始内存大小：物理内存大小/64;最大内存大小：物理内存大小/4
    • 手动设置：-Xms600m -Xmx600m
  • 查看设置的参数：
    • 方式一： ==终端输入jps== ， 然后 ==jstat -gc 进程id==
    • 方式二：（控制台打印）Edit Configurations->VM Options 添加 ==-XX:+PrintGCDetails==

8.2.1 查看内存大小

public class HeapSpaceInitial {
    public static void main(String[] args) {

        //返回Java虚拟机中的堆内存总量
        long initialMemory = Runtime.getRuntime().totalMemory() / 1024 / 1024;
        //返回Java虚拟机试图使用的最大堆内存量
        long maxMemory = Runtime.getRuntime().maxMemory() / 1024 / 1024;

        System.out.println("-Xms : " + initialMemory + "M");//-Xms : 245M
        System.out.println("-Xmx : " + maxMemory + "M");//-Xmx : 3641M

        System.out.println("系统内存大小为：" + initialMemory * 64.0 / 1024 + "G");//系统内存大小为：15.3125G
        System.out.println("系统内存大小为：" + maxMemory * 4.0 / 1024 + "G");//系统内存大小为：14.22265625G

        try {
            Thread.sleep(1000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

8.2.2 OOM

/**
 * -Xms600m -Xmx600m
 */
public class OOMTest {
    public static void main(String[] args) {
        ArrayList<Picture> list = new ArrayList<>();
        while(true){
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            list.add(new Picture(new Random().nextInt(1024 * 1024)));
        }
    }
}

class Picture{
    private byte[] pixels;

    public Picture(int length) {
        this.pixels = new byte[length];
    }
}

8.3 年轻代与老年代

  • 存储在JVM中的java对象可以被划分为两类
    • 一类是生命周期较短的瞬时对象,这类对象的创建和消亡都非常迅速
    • 另外一类是生命周期非常长,在某些情况下还能与JVM生命周期保持一致
  • Java堆区进一步细分可以分为年轻代和老年代
  • 其中年轻代可以分为Eden空间、Survivor0空间、Survivor1空间 1725a6811c74d76b.png
  • 配置新生代与老年代在堆结构中的占比
    • 默认-XX：NewRatio=2，表示新生代占1，老年代占2，新生代占整个堆的1/3
    • 可以修改-XX:NewRatio=4，表示新生代占1，老年代占4，新生代占整个堆的1/5
  • 在hotSpot中，Eden空间和另外两个Survivor空间缺省所占的比例是8：1：1（测试的时候是6：1：1），开发人员可以通过选项 -XX:SurvivorRatio 调整空间比例，如-XX:SurvivorRatio=8
  • 几乎所有的Java对象都是在Eden区被new出来的
  • 绝大部分的Java对象都销毁在新生代了（IBM公司的专门研究表明，新生代80%的对象都是“朝生夕死”的）
  • 可以使用选项-Xmn设置新生代最大内存大小（这个参数一般使用默认值就好了）
/**
 * -Xms600m -Xmx600m
 *
 * -XX:NewRatio ： 设置新生代与老年代的比例。默认值是2.
 * -XX:SurvivorRatio ：设置新生代中Eden区与Survivor区的比例。默认值是8
 * -XX:-UseAdaptiveSizePolicy ：关闭自适应的内存分配策略 '-'关闭,'+'打开  （暂时用不到）
 * -Xmn:设置新生代的空间的大小。 （一般不设置）
 *
 */
public class EdenSurvivorTest {
    public static void main(String[] args) {
        System.out.println("我只是来打个酱油~");
        try {
            Thread.sleep(1000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

8.4 图解对象分配过程

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

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

总结

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

1725a6b5a5099b93.png

对象分配的特殊情况

1725a6bccc4ef0bb.png

代码举例

public class HeapInstanceTest {
    byte[] buffer = new byte[new Random().nextInt(1024 * 200)];

    public static void main(String[] args) {
        ArrayList<HeapInstanceTest> list = new ArrayList<HeapInstanceTest>();
        while (true) {
            list.add(new HeapInstanceTest());
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

对应堆空间分配过程

1725a6c4bf09f89b.png

8.5 Minor GC/Major GC/Full GC

8.6 堆空间分代思想

8.7 内存分配策略

8.8 为对象分配内存:TLAB

8.9 小结堆空间的参数设置

8.10 堆是分配对象的唯一选择吗

avatar
文章
阅读
粉丝