深入理解JVM(一)——自动内存管理

Java内存区域与内存溢出异常

对于从事C、C++程序开发的开发人员来说,在内存管理领域,他们既是拥有最高权力的“皇帝”, 又是从事最基础工作的劳动人民——既拥有每一个对象的“所有权”,又担负着每一个对象生命从开始到终结的维护责任。

对于Java程序员来说,在虚拟机自动内存管理机制的帮助下,不再需要为每一个new操作去写配对 的delete/free代码,不容易出现内存泄漏和内存溢出问题,看起来由虚拟机管理内存一切都很美好。不过,也正是因为Java程序员把控制内存的权力交给了Java虚拟机,一旦出现内存泄漏和溢出方面的问 题,如果不了解虚拟机是怎样使用内存的,那排查错误、修正问题将会成为一项异常艰难的工作。

运行时数据区域

根据《Java虚拟机规范》的规定,Java虚拟机所管理的内存 将会包括以下几个运行时数据区域,如下所示。

JVM Run-time data areas

程序计数器

程序计数器(Program Counter Register)是一块较小的内存空间,它可以看作是当前线程所执行的字节码的行号指示器。在Java虚拟机的概念模型里,字节码解释器工作时就是通过改变这个计数器 的值来选取下一条需要执行的字节码指令,它是程序控制流的指示器,分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。

由于Java虚拟机的多线程是通过线程轮流切换、分配处理器执行时间的方式来实现的,在任何一个确定的时刻,一个处理器(对于多核处理器来说是一个内核)都只会执行一条线程中的指令。因此,为了线程切换后能恢复到正确的执行位置,每条线程都需要有一个独立的程序计数器,各条线程之间计数器互不影响,独立存储,我们称这类内存区域为“线程私有”的内存。

如果线程正在执行的是一个Java方法,这个技术记录的是正在执行的虚拟机字节码指令的地址;如果正在执行的是Native方法,这个计数器值则应为空(Undefined)。此内存区是唯一一个在《Java虚拟机规范》中没有规定任何OutOfMemoryError情况的区域。

Java虚拟机栈

与程序计数器一样,Java虚拟机栈(Java Virtual Machine Stack)也是线程私有的,它的生命周期与线程相同。

虚拟机栈描述的是Java方法执行的线程内存模型:每个方法被执行的时候,Java虚拟机都会同步创建一个栈帧(Stack Frame)用于存储局部变量表操作数栈动态连接方法出口等信息。每一个方法被调用直至执行完毕的过程,就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。

局部变量表存放了编译期可知的各种Java虚拟机基本数据类型(booleanbytecharshortintfloatlongdouble)、对象引用(reference类型,它并不等同于对象本身,可能是一个指向对象起始 地址的引用指针,也可能是指向一个代表对象的句柄或者其他与此对象相关的位置)和returnAddress 类型(指向了一条字节码指令的地址)。

在《Java虚拟机规范》中,对这个内存区域规定了两类异常状况:如果线程请求的栈深度大于虚拟机所允许的深度,将抛出StackOverflowError异常;如果Java虚拟机栈容量可以动态扩展,当栈扩展时无法申请到足够的内存会抛出OutOfMemoryError异常。

本地方法栈

本地方法栈(Native Method Stacks)与虚拟机栈所发挥的作用是非常相似的,其区别只是虚拟机栈为虚拟机执行Java方法(也就是字节码)服务,而本地方法栈则是为虚拟机使用到的本地(Native)方法服务。

《Java虚拟机规范》对本地方法栈中方法使用的语言、使用方式与数据结构并没有任何强制规定,因此具体的虚拟机可以根据需要自由实现它,甚至有的Java虚拟机(譬如Hot-Spot虚拟机)直接就把本地方法栈和虚拟机栈合二为一。与虚拟机栈一样,本地方法栈也会在栈深度溢出或者栈扩展失败时分别抛出StackOverflowError和OutOfMemoryError异常。

Java堆

对于Java应用程序来说,Java堆(Java Heap)是虚拟机所管理的内存中最大的一块。Java堆是被所有线程共享的一块内存区域,在虚拟机启动时创建。此内存区域存在的唯一目的就是存放对象实例,Java世界里几乎所有的对象实例都在这里分配内存。Java堆是垃圾收集器管理的内存区域,因此有些资料也称其为”GC堆“(Garbage Collected Heap)

从回收内存的角度看,现代垃圾收集器通常在逻辑上将Java堆分为”新生代“”老年代“”永久代“、”Eden空间“”From Survivor空间“等区域,但这些区域划分仅仅是一部分垃圾收集器的共同特性或者设计风格而已,而非某个Java虚拟机具体实现的固有内存布局,也与《Java虚拟机规范》无关。

从分配内存的角度看,所有线程共享的Java堆中可以划分出多个线程私有的分配缓冲区 (Thread Local Allocation Buffer,TLAB),以提升对象分配时的效率。不过无论从什么角度,无论如 何划分,都不会改变Java堆中存储内容的共性,无论是哪个区域,存储的都只能是对象的实例,将Java堆细分的目的只是为了更好地回收内存,或者更快地分配内存。

根据《Java虚拟机规范》的规定,Java堆可以处于物理上不连续的内存空间中,但在逻辑上它应该被视为连续的。如果堆中内有内存完成实例分配,并且堆也无法再扩展时,将会抛出OutOfMemoryError异常。

方法区

方法区(Method Area)与Java堆一样,是各个线程共享的内存区域,它用于存储已被虚拟机加载的类型信息、常量、静态变量、即时编译器编译后的代码缓存等数据。在《Java虚拟机规范》中把方法区描述为堆的一个逻辑部分,为了与Java堆区分,通常把它叫做”非堆(Non-Heap)“

方法区的内存使用超过限制会抛出OutOfMemory异常。

运行时常量池

运行时常量池(Runtime Constant Pool)是方法区的一部分。Class文件中除了有类的版本、字段、方法、接口等描述信息外,还有一项信息是常量池表(Constant Pool Table),用于存放编译期生成的各种字面量与符号引用,这部分内容将在类加载后存放到方法区的运行时常量池中。

Java虚拟机对于Class文件每一部分(自然也包括常量池)的格式都有严格规定,如每一个字节用于存储哪种数据都必须符合规范上的要求才会被虚拟机认可、加载和执行,但对于运行时常量池, 《Java虚拟机规范》并没有做任何细节的要求,不同提供商实现的虚拟机可以按照自己的需要来实现这个内存区域,不过一般来说,除了保存Class文件中描述的符号引用外,还会把由符号引用翻译出来的直接引用也存储在运行时常量池中。

运行时常量池相对于Class文件常量池的另外一个重要特征是具备动态性,Java语言并不要求常量一定只有编译期才能产生,也就是说,并非预置入Class文件中常量池的内容才能进入方法区运行时常 量池,运行期间也可以将新的常量放入池中,这种特性被开发人员利用得比较多的便是String类的intern()方法。

既然运行时常量池是方法区的一部分,自然受到方法区内存的限制,当常量池无法再申请到内存时会抛出OutOfMemoryError异常。

直接内存

直接内存(Direct Memory)并不是虚拟机运行时数据区的一部分,也不是《Java虚拟机规范》中定义的内存区域,但是这部分内存也被频繁地使用,而且也可能导致OutOfMemoryError异常出现。

在JDK 1.4中新加入了NIO(New Input/Output)类,引入了一种基于通道(Channel)与缓冲区(Buffer)的I/O方式,它可以使用Native函数库直接分配堆外内存,然后通过一个存储在Java堆里面的DirectByteBuffer对象作为这块内存的引用进行操作。这样能在一些场景中显著提高性能,因为避免了在Java堆和Native堆中来回复制数据。

显然,本机直接内存的分配不会受到Java堆大小的限制,但是,既然是内存,则肯定还是会受到本机总内存(包括物理内存、SWAP分区或者分页文件)大小以及处理器寻址空间的限制,一般服务器管理员配置虚拟机参数时,会根据实际内存去设置-Xmx等参数信息,但经常忽略掉直接内存,使得各个内存区域总和大于物理内存限制(包括物理的和操作系统级的限制),从而导致动态扩展时出现OutOfMe-moryError异常。

HotSpot虚拟机对象探秘

接下来我们以最常见的虚拟机HotSpot和内存区域Java堆为例,深入探讨一下HotSpot虚拟机在Java堆中对象分配、布局和访问过程。

对象的创建

Java是一门面向对象的编程语言,Java程序运行过程中无时无刻都有对象被创建出来。在语言层面上,创建对象通常(例外:复制、反序列化)仅仅是一个new关键字而已,而在虚拟机中,对象(文中讨论的对象限于普通Java对象,不包括数组和Class对象等)的创建又是怎样一个过程呢?

先看一张图:

Java Object Creation

我们来分析一下这个流程。

当Java虚拟机遇到一条字节码new指令时,首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号引用,并且检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有,那必须先执行相应的类加载过程。

在类加载检查通过后,接下来虚拟机将为新生对象分配内存。对象所需内存的大小在类加载完成后便可完全确定,为对象分配空间的任务实际上便等同于把一块确定 大小的内存块从Java堆中划分出来。Java堆中有两种内存分配方式,分别是”指针碰撞“”空闲列表“

  • 指针碰撞(Bump The Pointer):已分配内存和空闲内存之间放置一个作为分界点的指示器,通过移动这个指示器来调整空闲空间的大小实现对象的内存分配。这种分配方式适合内存绝对规整的情况。
  • 空闲列表(Free List):如果Java堆中的内存并不是规整的,已被使用的内存和空闲的内存相互交错在一起,那就没有办法简单地进行指针碰撞了,虚拟机就必须维护一个列表,记录上哪些内存块是可用的,在分配的时候从列表中找到一块足够大的空间划分给对象实例,并更新列表上的记录。

选择哪种分配方式由Java堆是否规整决定,而Java堆是否规整又由所采用的垃圾收集器是否带有空间压缩整理(Compact)的能力决定。因此,当使用Serial、ParNew等带压缩整理过程的收集器时,系统采用的分配算法是指针碰撞,既简单又高效;而当使用CMS这种基于清除(Sweep)算法的收集器时,理论上就只能采用较为复杂的空闲列表来分配内存。

除了划分可用内存空间之外,对象的创建实际上还会有线程安全的问题:可能出现正在给对象A分配内存,指针还没来得及修改,对象B又同时使用了原来的指针来分配内存的情况。要解决这个问题有两种可选方案:

  1. 对分配内存空间的动作进行同步处理。实际上虚拟机是采用CAS配上失败重试的方式保证更新操作的原子性。
  2. 把内存分配的动作按照线程划分在不同的空间之中进行。这种情况需要每个线程预先在堆上分配一小块内存,称为本地线程分配缓冲(Thread Local Allocation Buffer,TLAB),哪个线程要分配内存,就先到它的TLAB中分配,只有TLAB满了,分配新的缓存区时才需要同步锁定。

分配完内存之后,虚拟机必须将分配到的内存空间(但不包括对象头)都初始化为零值,如果使用了TLAB的话,这一项工作也可以提前至TLAB分配时顺便进行。

接下来JVM需要对对象进行必要的设置,例如接下来,Java虚拟机还要对对象进行必要的设置,例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码(实际上对象的哈希码会延后到真正调用Object::hashCode()方法时才计算)、对象的GC分代年龄等信息。这些信息存放在对象的对象头(Object Header)之中

完成上面的工作之后,在虚拟机看来实际上一个新的对象已经产生了。不过从程序角度来看,还需要调用构造函数来初始化对象的资源和状态。因此new指令之后接着会执行Class文件中的()方法,按照程序员的意愿对对象进行初始化,这样一个真正可用的对象才算完全被构造出来。

对象的内存布局

在HotSpot虚拟机里,对象在堆内存中的存储布局可以划分为三个部分:对象头(Header)实例数据(Instance Data)对齐填充(Padding)。如下图所示。

HotSpot虚拟机对象存储分布

其中MarkWord是一个有着动态定义的数据结构,在未开启指针压缩的情况,在32位和64位虚拟机上的长度分别为32个比特和64个比特。

例如在32位的HotSpot虚拟机中,如对象未被同步锁锁定的状态下,Mark Word的32个比特存储空间中的25个比特用于存储对象哈希码,4个比特用于存储对象分代年龄,2个比特用于存储锁标志位,1个比特固定为0,在其他状态(轻量级锁定、重量级锁定、GC标记、可偏向)下对象的存储内容如下表所示。

存储内容 标志位 状态
对象哈希码、分代年龄 01 未锁定
指向锁记录的指针 00 轻量级锁定
指向重量级锁的指针 10 膨胀(重量级锁定)
空,不需要记录信息 11 GC标记
偏向线程ID、偏向时间戳、对象分代年龄 01 可偏向

对象的访问定位

创建对象自然是为了后续使用该对象,我们的Java程序会通过栈上的reference数据来操作堆上的具体对象。由于reference类型在《Java虚拟机规范》里面只规定了它是一个指向对象的引用,并没有定义这个引用应该通过什么方式去定位、访问到堆中对象的具体位置,所以对象访问方式也是由虚拟机实现而定的,主流的访问方式有使用句柄直接指针两种:

  • 使用句柄访问时,Java堆中会划分出一块内存来作为句柄池,reference中存储的就是对象的句柄地址。句柄中包含了对象实例数据与类型数据各自具体的地址信息,如下图所示。

通过句柄访问对象

  • 使用直接指针访问时,Java堆中对象的内存布局就必须考虑如何放置访问数据类型的相关信息,reference中存储的直接就是对象地址。如果只是访问对象本身的话,就不需要额外的间接访问开销了,如下图所示。

通过直接指针访问对象

垃圾收集器与内存分配策略

垃圾收集简称GC(Garbage Collection),它主要需要完成三件事:

  • 那些内存需要回收?
  • 什么时候回收?
  • 如何回收?

上面介绍了Java内存运行时区域的各个部分,我们知道线程私有的区域可以随着线程的销毁而进行内存的清理工作,而Java堆和方法区是线程共享的部分,这部分内存的分配和回收是动态的,所以是垃圾收集器重点关注的区域,本文讨论的也是这两个区域。

对象已死?

在Java堆中存放这Java世界中几乎所有的对象实例,垃圾收集器在堆堆进行GC钱,第一件事就是要确认哪些对象的实例”活着“,哪些对象已经”死亡“需要被回收。

目前主流的判断对象存活的算法有两种:

  • 引用计数法
  • 可达性分析法

引用计数法

引用计数:在对象中添加一个引用计数器,每当有一个地方引用它时,计数器值就加一;当引用失效时,计数器值就减一;任何时刻计数器为零的对象就是不可能再被使用的。

此算法简单且高效,只需要占用一些额外的内存空间来进行计数,但主流的JVM都没有选用这个算法来管理内存,主要原因是:这个看似简单的算法有很多例外情况要考虑,必须要配合大量额外处理才能保证正确地工作,譬如单纯的引用计数就很难解决对象之间相互循环引用的问题。

这也是常说的”循环引用“问题,举个简单的例子:

1
2
3
4
5
6
7
8
9
// <-- 背景 -->
// 对象objA 和 objB 都有字段 name
// 两个对象相互进行引用,除此之外这两个人对象没有任何引用
objA.name = objB;
objB.name = objA;

// <-- 问题 -->
// 实际上这两个对象已经不可能再被访问,应该要被垃圾收集器进行回收
// 但因为他们相互引用,所以导致计数器不为0,这导致引用计数算法无法通知垃圾收集器回收该两个对象

当出现循环引用时,两个对象已经”死亡“,但实际上由于引用计数器不为0而无法被回收引起泄露。

可达性分析法

当前主流的商用程序语言(Java、C#,上溯至前面提到的古老的Lisp)的内存管理子系统,都是通过可达性分析算法来判定对象是否存活的。

可达性分析(Reachability Analysis):通过一系列称为“GC Roots”的根对象作为起始节点集,从这些节点开始,根据引用关系向下搜索,搜索过程所走过的路径称为”引用链”(Reference Chain),如果某个对象到GC Roots间没有任何引用链相连, 或者用图论的话来说就是从GC Roots到这个对象不可达时,则证明此对象是不可能再被使用的。

可达性分析法

如上图所示,与GC Root不存在引用链的对象将会被判为“死亡”对象,在下一次GC时进行回收。

Java中固定可作为GC Root的对象包括以下几种:

  • 虚拟机栈中引用的对象,即栈帧中的本地变量表,里面存放了各个线程被调用的方法堆栈中使用到的参数、局部变量、临时变量等。
  • 方法区中类静态属性引用的对象,例如Java类的引用类型静态变量。
  • 在方法区中常量引用的对象,例如字符串常量池(String Table)里的引用。
  • 在本地方法栈中JNI(即通常所说的Native方法)引用的对象。
  • Java虚拟机内部的引用,如基本数据类型对应的Class对象,一些常驻的异常对象(比如NullPointExcepiton、OutOfMemoryError)等,还有系统类加载器。
  • 所有被同步锁(synchronized关键字)持有的对象。
  • 反映Java虚拟机内部情况的JM XBean、JVM TI中注册的回调、本地代码缓存等。

除了上述固定的GC Roots集合以外,根据用户所选用的垃圾收集器以及当前回收的内存区域不同,还可以有其他对象“临时性”地加入,共同构成完整GC Roots集合。例如发生局部回收(Partial GC)时,如果只针对Java堆中某一块区域发起垃圾收集,这个区域里的对象完全有可能被区域外部的其他对象引用,例如下图中的B对象。此时A对象会被一并加入到GC Roots集合中,充当临时的GC Root,才能保证可达性分析的准确性。

局部GC

生存还是死亡?

一个对象要真正被垃圾回收器回收,除了要在可达性分析判断为不可达对象外,还要经历至少两次标记过程:如果对象在进行可达性分析后发现没有与GC Roots相连接的引用链,那它将会被第一次标记,随后进行一次筛选,筛选的条件是此对象是否有必要执行finalize方法。如果对象没有复写finalize方法或者finalize方法已经被调用过一次了,那么这两种情况都被视为“没有必要执行”。

如果这个对象被判定为确有必要执行finalize()方法,那么该对象将会被放置在一个名为F-Queue的队列之中,并在稍后由一条由虚拟机自动建立的、低调度优先级的Finalizer线程去执行它们的finalize() 方法。这里所说的“执行”是指虚拟机会触发这个方法开始运行,但并不承诺一定会等待它运行结束。 不承诺它一定结束的原因是,finalize()方法可能会很耗时或者存在死循环导致其他对象无法正常执行finalize()。finalize()方法是对象逃脱死亡命运的最后一次机会,稍后收集器将对F-Queue中的对象进行第二次小规模的标记,如果对象要在finalize()中成功拯救自己——只要重新与引用链上的任何一个对象建立关联即可,譬如把自己 (this关键字)赋值给某个类变量或者对象的成员变量,那在第二次标记时它将被移出“即将回收”的集合;如果对象这时候还没有逃脱,那基本上它就真的要被回收了。

垃圾收集算法

圾收集算法可以划分为“引用计数式垃圾收集”(Reference Counting GC)“追踪式垃圾收集”(Tracing GC)两大类,这两类也常被称作“直接垃圾收集”和“间接垃圾收集”。本文主要探讨追踪式垃圾收集。

分代收集理论

当前商业虚拟机的垃圾收集器,大多数都遵循了“分代收集”(Generational Collection)的理论进行设计,它建立在两个假说之上:

  1. 弱分代假说(Weak Generational Hypothesis):绝大多数对象都是朝生夕灭的。
  2. 强分代假说(Strong Generational Hypothesis):熬过越多次垃圾收集过程的对象就越难以消亡。

基于这两个假说,垃圾收集器可以将 Java堆划分为不同的区域,根据对象的年龄将其分配到不同区域中,在不同的区域中采用不同的垃圾收集频率和算法。例如虚拟机中可能存在下列几种算法:

  • 部分收集(Partial GC):指目标不是完整收集整个Java堆的垃圾收集。
    • 新生代收集(Minor GC/Young GC):指目标只是新生代的垃圾收集。
    • 老年代收集(Major GC/Old GC):指目标只是老年代的垃圾收集。
    • 混合收集(Mixed GC):指目标是收集整个新生代以及部分老年代的垃圾收集。
  • 整堆收集(Full GC):收集整个Java堆和方法区的垃圾收集。

例如我们可以将Java堆粗略的分为新生代(Young Generation)老年代(Old Generation)两个区域。在新生代中,每次垃圾收集时都发现有大批对象死去,而每次回收后存活的少量对象,将会逐步晋升到老年代中存放。

我们可以在新生代和老年代分别进行GC操作,这就引申出一个问题:对象不是孤立的,对象之间会存在跨代引用。假如要现在进行一次只局限于新生代区域内的收集(Minor GC),但新生代中的对象是完全有可能被老年代所引用的,为了找出该区域中的存活对象,不得不在固定的GC Roots之外,再额外遍历整个老年代中所有对象来确保可达性分析结果的正确性,反过来也是一样。为了解决这个问题,就需要对分代收集理论添加第三条经验法则:

  • 跨代引用假说(Intergenerational Reference Hypothesis):跨代引用相对于同代引用来说仅占极少数。

依据这条假说,我们只需在新生代上建立一个全局的数据结构(该结构被称为“记忆集”,Remembered Set),这个结构把老年代划分成若干小块,标识出老年代的哪一块内存会存在跨代引用。此后当发生Minor GC时,只有包含了跨代引用的小块内存里的对象才会被加入到GC Roots进行扫描。

标记-清除算法

标记-清除(Mark-Sweep)算法是最早出现也是最基础的垃圾收集算法,它分为“标记”和“清除”两个阶段:

  • 标记(Mark):标记所有需要清除或者保留的对象。
  • 清除(Sweep):回收所有被标记或者未被标记的对象。

标记-清除算法是最基础的收集算法,后续的收集算法大多都是基于它改进产生的。为什么需要改进呢,是因为它有两个比较明显的缺点:

  • 执行效率不稳定:标记和清除两个过程的执行效率随着对象数量增长而降低。
  • 内存空间碎片化:标记、清除之后会产生大量不连续的内存碎片,会导致后续需要分配大对象例如数组的时候无法找到连续内存而发生OOM。

标记-清除算法的执行过程如下图所示。

标记-清除算法执行过程

标记-复制算法

标记-复制(Mark-Copy)算法常被简称为复制算法。它将可用内存按容量划分为大小相等的两块,每次只使用其中的一块,当这一块内存用完的时候,就将这块内存上存活的对象复制到另一块内存中,最后将之前那块内存一次清理掉。

标记-复制算法可以解决标记-清除中内存碎片过多的问题,但缺点也是显而易见的:将可用内存缩小为了原来的一半。

标记-复制算法执行过程如下图所示。

标记-复制算法执行过程

现在的商用Java虚拟机大多都优先采用了这种收集算法去回收新生代,但并不按照1:1的比例来划分新生代的内存空间,而是把新生代划分为一块较大的Eden空间和两块较小的Survivor空间,每次分配内存只考虑Eden空间和其中的一块Survivor。当发生GC时,将Eden和Survivor中仍然存活的对象一次性复制到另外一块Survivor空间上,然后直接清理掉Eden和已用过的那块Survivor空间。

HotSpot虚拟机默认Eden和Survivor的大小比例是8∶1,也就是说将原先标记-复制算法浪费一半空间的问题缩小到了10%。当然这个算法也有一个问题,就是只预留10%的新生代空间,有可能会存在这10%空间不足以将存活的对象复制过去的问题,所以实际中发生这个问题时还会有老年代参与进来接收这些不足够存放的对象。

标记-整理算法

我们前面讨论了新生代要如何进行分区进行标记-复制算法的问题。新生代中对象“朝生夕灭”,每次GC只需要复制少量的对象即可完成算法过程。但老年代中对象存活率较高,如果需要频繁的进行复制操作,效率将会很低,因此老年代中一般不会采用标记-复制算法。

标记-整理(Mark-Compact)算法与标记清除-算法类似,不同的是在标记后不会立即进行清理,而是先进行让所有存活的对象都向内存空间的一端进行移动,即”整理“,然后直接清除掉边界以外的内存。步骤如下:

  1. 标记阶段:标记出所有需要回收的对象;
  2. 整理阶段:让所有存活的对象都向一端移动
  3. 清除阶段:统一清除(回收)端以外的对象。

算法执行过程如下图所示。

标记-整理算法执行过程

标记-清除算法与标记-整理算法的本质差异在于前者是一种非移动式的回收算法,而后者是移动式的。

参考