JVM运行时数据区

JVM 的栈与寄存器

1. 运行时数据区知识回顾

运行时数据区又可以细分为五个模块：栈，堆，寄存器，方法区和本地方法栈，如下图所示。

本节我们主要针对讲解栈（Java 栈与和地方法栈）与寄存器（程序计数器），其他 2 个模块，方法区和堆会在后续的内容中进行讲解。

2. 栈的基本介绍

基本概念：Java 栈有两个，分别是虚拟机栈和本地方法栈。这里以虚拟机栈为例，本地方法栈和虚拟机栈基本相同。

栈的特点：对于每个线程，将创建单独的运行时栈。对于每个方法调用，将在栈存储器中产生一个条目，称为栈帧。所有局部变量将在栈内存中创建。栈区域是线程安全的，因为它不共享资源。

• Java 虚拟机栈是线程私有的，它的生命周期与线程相同（随线程而生，随线程而灭）；
• 如果线程请求的栈深度大于虚拟机所允许的深度，将抛出 StackOverflowError 异常；如果虚拟机栈可以动态扩展，如果扩展时无法申请到足够的内存，就会抛出 OutOfMemoryError 异常；
• Java 虚拟机栈描述的是 Java 方法执行的内存模型：每个方法执行的同时会创建一个栈帧。对于我们来说，主要关注的栈内存，就是虚拟机栈中局部变量表部分。

Tips：从栈的特点的最后一点可以看到，开发者主要关注的是栈内存，而栈内存的消耗是因为每个方法执行的同时会创建一个栈帧，而占用空间最大的部分就是栈帧的局部变量表部分。后续我们会展开讲解。

3. 栈帧

定义：栈帧（Stack Frame）是用于支持虚拟机进行方法调用和方法执行的数据结构。它是虚拟机运行时数据区中的 java 虚拟机栈的栈元素。栈帧存储了方法的局部变量表、操作数栈、动态链接和方法返回地址等信息。

栈帧初始化大小：在编译程序代码的时候，栈帧中需要多大的局部变量表内存，多深的操作数栈都已经完全确定了。 因此一个栈帧需要分配多少内存，不会受到程序运行期变量数据的影响，而仅仅取决于具体的虚拟机实现。

栈帧结构：如下图所示，在一个线程中，只有位于栈顶的栈帧才是有效的，称为当前栈帧，与这个栈帧相关联的方法称为当前方法。每一个方法从调用开始至执行完成的过程，都对应着一个栈帧在虚拟机里面从入栈到出栈的过程。

从上图中我们能够看到，栈帧的组成结构，下文我们将对局部变量表，操作数栈，动态链表以及返回地址进行讲解。

4. 栈帧 - 局部变量表

在栈帧中，局部变量表占用了大部分的空间，那么接下来我们看下局部变量表的基本概念与特点。

基本概念：每个栈帧中都包含一组称为局部变量表的变量列表，用于存放方法参数和方法内部定义的局部变量。

特点：

• 局部变量表的容量以变量槽（Variable Slot）为最小单位；
• 在方法执行过程中，Java 虚拟机是使用局部变量表完成参数值到参数变量列表的传递过程；
• 局部变量表中的 Slot 是可重用的，方法体中定义的变量，其作用域并不一定会覆盖整个方法体，如果当前字节码程序计数器的值已经超过了某个变量的作用域，那么这个变量相应的 Slot 就可以交给其他变量去使用，节省栈空间。

5. 栈帧 - 操作数栈

操作数栈也是栈帧中非常重要的结构，操作数栈不需要占用很大的空间，那么我们一起来看下操作数栈的作用及特点。

• 操作数栈是一个后入先出（Last In First Out）栈，方法的执行操作在操作数栈中完成，每一个字节码指令往操作数栈进行写入和提取的过程，就是入栈和出栈的过程；
• 操作数栈的每一个元素可以是任意的 Java 数据类型，32 位数据类型所占的栈容量为 1，64 位数据类型所占的栈容量为 2；
• 当一个方法刚刚执行的时候，这个方法的操作数栈是空的，在方法执行的过程中，通过一些字节码指令从局部变量表或者对象实例字段中复制常量或者变量值到操作数栈中。

6. 栈帧 - 动态链接与返回地址

动态链接的基本概念及作用如下：

• 每个栈帧都包含一个指向运行时常量池（JVM 运行时数据区域）中该栈帧所属方法属性的引用，持有这个引用是为了支持方法调用过程中的动态链接。
• 在 Class 文件格式的常量池（存储字面量和符号引用）中存有大量的符号引用（1. 类的全限定名，2. 字段名和属性，3. 方法名和属性），字节码中的方法调用指令就以常量池中指向方法的符号引用为参数。
  这些符号引用一部分会在类加载过程的解析阶段的时候转化为直接引用（指向目标的指针、相对偏移量或者是一个能够直接定位到目标的句柄），这种转化称为静态解析。另外一部分将在每一次的运行期期间转化为直接引用，这部分称为动态链接。

返回地址：返回地址代表的是方法执行结束，方法执行结束有两种方式，我们来具体看下栈帧中返回地址的作用：

• 当一个方法开始执行后，只有两种方式可以退出这个方法。第一种方式是执行引擎遇到任意一个方法返回的字节码指令（例如：return），这时候可能会有返回值传递给上层的方法调用者（调用当前方法的方法称为调用者），是否有返回值和返回值的类型将根据遇到何种方法返回指令来决定，这种退出方法的方式称为正常完成出口（Normal Method Invocation Completion）。
• 另外一种退出方式是，在方法执行过程中遇到了异常，并且这个异常没有在方法体内得到处理，无论是 Java 虚拟机内部产生的异常，还是代码中使用 throw 字节码指令产生的异常，只要在本方法的异常处理器表中没有搜索到匹配的异常处理器，就会导致方法退出，这种退出方法的方式称为异常完成出口（Abrupt Method Invocation Completion）。一个方法使用异常完成出口的方式退出，是不会给它的上层调用者产生任何返回值的。
• 方法退出的过程实际上就等同于把当前栈帧出栈，因此退出时可能执行的操作有：恢复上层方法的局部变量表和操作数栈，把返回值（如果有的话）压入调用者栈帧的操作数栈中，调整程序计数器的值以指向方法调用指令后面的一条指令等。

7. 寄存器简介

寄存器（ PC register ）基本概念：每个线程启动的时候，都会创建一个 PC（Program Counter，程序计数器）寄存器。PC 寄存器里保存有当前正在执行的 JVM 指令的地址。

寄存器简介：

• 每一个线程都有它自己的 PC 寄存器，也是该线程启动时创建的。保存下一条将要执行的指令地址的寄存器是：PC 寄存器。PC 寄存器的内容总是指向下一条将被执行指令的地址，这里的地址可以是一个本地指针，也可以是在方法区中相对应于该方法起始指令的偏移量；
• 每个线程都有一个寄存器，是线程私有的，其实就是一个指针，指向方法区中的方法字节码（用来存储指向下一条指令的地址，以及即将要执行的指令代码），由执行引擎读取下一条指令，是一个非常小的内存空间，几乎可以忽略不记；
• 这块内存区域很小，它是当前线程所执行的字节码的行号指示器，字节码解释器通过改变这个计数器的值来选取下一条需要执行的字节码指令。
• 如果执行的是一个 Native 方法，那这个计数器是空的。

8. 寄存器的特点

通过对寄存器的介绍，我们知道，寄存器器是用来存储指向下一条指令的地址，以及即将要执行的指令代码。我们来看下寄存器的特点：

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

JVM 方法区

1. 什么是方法区

定义：方法区，也称非堆（Non-Heap），是一个被线程共享的内存区域。其中主要存储加载的类字节码、class/method/field 等元数据对象、static-final 常量、static 变量、JIT 编译器编译后的代码等数据。另外，方法区包含了一个特殊的区域 “运行时常量池”。

Tips：对于运行时常量池，后文会有讲解。

对于习惯在 HotSpot 虚拟机上开发和部署程序的开发者来说，很多人愿意把方法区称为 “永久代”（Permanent Generation），本质上两者并不等价，仅仅是因为 HotSpot 虚拟机的设计团队选择把 GC 分代收集扩展至方法区，或者说使用永久代来实现方法区而已。对于其他虚拟机（如 BEA JRockit、IBM J9 等）来说是不存在永久代的概念的。

2. 方法区存放的数据

在讲解方法区内存放的数据之前，我们先通过示意图来直观的看下，方法区存放的数据与堆内存之间的关系。如下图所示

从图中可以看到，方法区存放了 ClassLoader 对象的引用，也存放了一个到类对象的引用，这两个引用的对象实例会存放到堆内存中。从上图我们就可以简单的了解到方法区存放的数据是什么，接下来，我们对存放的数据类型进行解释。

• 类型全限定名：全限定名为 package 路径与类名称组合起来的路径；
• 类型的直接超类的全限定名：父类或超类的全限定名；
• 类型是类类型还是接口类型：判定当前类是 Class 还是接口 Interface；
• 类型的访问修饰符：判断修饰符，如 pulic，private 等；
• 类型的常量池：这部分会在下文进行讲解；
• 字段信息：类中字段的信息；
• 方法信息：类中方法的信息；
• 静态变量：类中的静态变量信息；
• 一个到类 ClassLoader 的引用：对 ClassLoader 的引用，这个引用指向对内存；
• 一个到 Class 类的引用：对对象实例的引用，这个引用指向对内存。

3. 运行时常量池

我们先来回顾下Class 文件结构中的常量池的相关知识。

Class 文件中的常量池：
在 Class 文件结构中，最头的 4 个字节用于存储 Megic Number，用于确定一个文件是否能被 JVM 接受，再接着 4 个字节用于存储版本号，前 2 个字节存储次版本号，后 2 个存储主版本号，再接着是用于存放常量的常量池，由于常量的数量是不固定的，所以常量池的入口放置一个 u2 类型的数据 (constant_pool_count) 存储常量池容量计数值。

常量池主要用于存放两大类常量：字面量（Literal）和符号引用量（Symbolic References）。

运行时常量池：我们回到正题，来看下运行时常量池。

Tips：其实 Class 文件中的常量池与运行时常量池的关系非常容易理解，Class 文件中的常量池用于存放编译期生成的各种字面量和符号引用，这部分内容将在类加载后进入方法区的运行时常量池中存放。简单总结来说，编译器使用 Class 文件中的常量池，运行期使用运行时常量池。

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

4. 常量池的优势

常量池是为了避免频繁的创建和销毁对象而影响系统性能，其实现了对象的共享。

例如字符串常量池，在编译阶段就把所有的字符串文字放到一个常量池中。

• 节省内存空间：常量池中所有相同的字符串常量被合并，只占用一个空间。
• 节省运行时间：比较字符串时，== 比 equals () 快。对于两个引用变量，只用 == 判断引用是否相等，也就可以判断实际值是否相等。

4. 方法区内存变更

方法区的实现，虚拟机规范中并未明确规定，目前有 2 种比较主流的实现方式：

HotSpot 虚拟机 1.8之前：在 JDK1.6 及之前版本，HotSpot 使用 “永久代（permanent generation）” 的概念作为实现，即将 GC 分代收集扩展至方法区。这种实现比较偷懒，可以不必为方法区编写专门的内存管理，但带来的后果是容易碰到内存溢出的问题（因为永久代有 - XX:MaxPermSize 的上限）。

在 JDK1.7，HotSpot 逐渐改变方法区的实现方式，如 1.7 版本移除了方法区中的字符串常量池，但未发生本质的变化。

HotSpot 虚拟机 1.8之后：1.8 版本中移除了方法区并使用 metaspace（元数据空间）作为替代实现。metaspace 占用系统内存，也就是说，只要不碰触到系统内存上限，方法区会有足够的内存空间。但这不意味着我们不对方法区进行限制，如果方法区无限膨胀，最终会导致系统崩溃。

JVM 堆内存

1. 堆内存结构

堆内存是运行时数据区中非常重要的结构，实例对象会存放于堆内存中。绝大多数的垃圾回收都发生在堆内存中，因此对于 JVM 来说，堆内存占据着十分重要的且不可替代的位置。

我们先来看下堆内存的结构图，初步了解堆内存的整体内存划分。

从上图可以看到如下几个要点：

• 堆内存从结构上来说分为年轻代（YoungGen）和老年代（OldGen）两部分；
• 年轻代（YoungGen）又可以分为生成区（Eden）和幸存者区（Survivor）两部分；
• 幸存者区（Survivor）又可细分为 S0区（from space）和 S1区 (to space)两部分。

从图中，我们能够大体了解堆内存的结构划分，后文在讲解分代概念时，我们会提供更加直观，更加清晰的内存结构图。

2. 什么是堆内存

物理层面：从物理层面（硬件层面）来说，当 Java 程序开始运行时，JVM 会从操作系统获取一些内存。JVM 使用这些内存，这些内存的一部分就是堆内存。

Java层面：从开发层面来说，堆内存通常在存储地址的底层，向上排列。当一个对象通过 new 关键字或通过其他方式创建后，对象从堆中获得内存。当对象不再使用了，被当做垃圾回收掉后，这些内存又重新回到堆内存中。

总结来说，堆内存是JVM启动时，从操作系统获取的一片内存空间，他主要用于存放实例对象本身，创建完成的对象会放置到堆内存中。

3. 堆内存的分代概念

从上文堆内存的结构图中，我们看到了比较多的JVM堆内存中的专有名词，比如：年轻代，老年代。那么对于堆内存来说，分代是什么意思呢？为什么要进行分代呢？

分代：将堆内存从概念层面进行模块划分，总体分为两大部分，年轻代和老年代。从物理层面将堆内存进行内存容量划分，一部分分给年轻代，一部分分给老年代。这就是我们所说的分代。

分代的意义：易于堆内存分类管理，易于垃圾回收。类似于我们经常使用的 Windows 操作系统，我们会将物理磁盘划出一部分存储空间作为用户系统安装盘（如 C 盘），我们还极大可能将剩余的磁盘空间划分为 C, D, E 等磁盘，用于存储同一类型的数据。

• 易于管理：对于堆空间的分代也是如此，比如新创建的对象会进入年轻代（YoungGen）的生成区（Eden），生命周期未结束的且可达的对象，在经历多次垃圾回收之后，会存放入老年代（OldGen），这就是分类管理；
• 易于垃圾回收：将对象根据存活概率进行分类，对存活时间长的对象，放到固定区，从而减少扫描垃圾时间及 GC 频率。针对分类进行不同的垃圾回收算法，对算法扬长避短。

4. 堆内存结构详解

讲解完分代的概念，我们来对堆内存中的不同的代，不同的内存空间的作用进行更加详细的讲解。讲解之前，我们来看下如下示意图，更加直观的了解堆内存结构。

堆内存每个模块之间的关系及各自的特点概述如下：

• JVM 内存划分为堆内存和非堆内存，堆内存分为年轻代（YoungGen）、老年代（OldGen）；
• 年轻代又分为 Eden 和 Survivor 区。Survivor 区由 FromSpace 和 ToSpace 组成。Eden 区占大容量，Survivor 两个区占小容量，默认比例是 8:1:1；
• 堆内存存放的是对象，垃圾收集器就是收集这些对象，然后根据 GC 算法回收；
• 新生成的对象首先放到年轻代 Eden 区，当 Eden 空间满了，触发 Minor GC，存活下来的对象移动到Survivor0 区，Survivor0 区满后触发执行 Minor GC，Survivor0 区存活对象移动到 Suvivor1 区，这样保证了一段时间内总有一个 survivor 区为空。经过多次 Minor GC 仍然存活的对象移动到老年代；
• 老年代存储长期存活的对象，GC 期间会停止所有线程等待 GC 完成，所以对响应要求高的应用尽量减少发生 Major GC，避免响应超时。

JVM 中堆的对象转移与年龄判断

1. 对象优先在Eden 区分配

Tips：标题中“优先”一次需要学习者认真品味，“优先” 意味着首先考虑，那么在一些特殊情况下，新创建的对象还是有可能不在Eden区分配的。这种特殊情况我们在讲解老年代（OldGen）的时候再进行说明。

上节课程我们学习了，Eden 区属于年轻代（YoungGen）。在创建新的对象时，大多数情况下，对象先在 Eden 区中分配。当 Eden 区没有足够空间进行分配时，虚拟机将发起一次 Minor GC。

那我们如何进行证明，新创建的对象优先在Eden 区分配呢？为了对这个结论进行验证，我们来设计如下实验。

实验设计：

• 创建了一个类，类名称可自定义，并在类中实现一个 main 函数，为后续测试做前提准备；
• 在运行main函数之前，通过设置 JVM 参数，设置堆内存初始大小为 20M，最大为 20M，其中年轻代大小为 10M，不需要特殊设置 Eden 区的大小；
• 除了设置堆内存参数之外，还需要设置JVM 参数跟踪详细的垃圾回收日志，以便于观察年轻代（YoungGen）的内存使用情况；
• 设置完成后，main 函数不写任何代码，运行空的 main 函数观察打印日志；
• 在main函数中创建一个 2M 大小的对象，运行 main 函数观察打印日志。

Tips：实验中会用到两种JVM的参数配置，一种是配置堆内存的参数，另外一种是配置跟踪垃圾回收的参数。

实验要点准备：

• 设置堆内存大小为 20M，最大为 20M，其中年轻代大小为 10M，并设置垃圾跟踪日志打印。需要通过JVM参数 -Xms20m -Xmx20m -Xmn10m -XX:+PrintGCDetails 进行设置；
• 不需要特殊设置 Eden 区的大小，那么年轻代中 Eden 区、from space 和 to space 将会以默认的 8:1:1进行空间分配；
• 创建一个 2M 大小的对象，我们可以通过语句 byte[] obj = new byte[2*1024*1024] 来实现。

空运行main函数代码演示：

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

空运行mian函数日志：

Heap
 PSYoungGen      total 9216K, used 2370K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
  eden space 8192K, 28% used [0x00000000ff600000,0x00000000ff850aa0,0x00000000ffe00000)
  from space 1024K, 0% used [0x00000000fff00000,0x00000000fff00000,0x0000000100000000)
  to   space 1024K, 0% used [0x00000000ffe00000,0x00000000ffe00000,0x00000000fff00000)
 ParOldGen       total 10240K, used 0K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  object space 10240K, 0% used [0x00000000fec00000,0x00000000fec00000,0x00000000ff600000)
 Metaspace       used 3439K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 374K, capacity 388K, committed 512K, reserved 1048576K

结果分析：我们主要关注 PSYoungGen（年轻代）下的内存分配。空运行情况下，我们看到 Eden 区的大小为 8192K，已使用 28%。为什么空运行下还会有 28% 的内存使用呢？这 28% 的内存使用，包括了支持main函数运行的对象实例。

新建 2M 对象的代码演示：

public class DemoTest {
    public static void main(String[] args) {
        byte[] obj = new byte[2*1024*1024];
    }
}

新建 2M 对象的运行日志：此处我们只展示年轻代的运行日志。

PSYoungGen      total 9216K, used 4418K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
  eden space 8192K, 53% used [0x00000000ff600000,0x00000000ffa50ac8,0x00000000ffe00000)

结果分析：我们看到，新建 2M 的对象之后，Eden 区使用的空间从之前的 28% 增长到了 53%，净增长 25%。那么我们来进行简单的计算 Eden 区的总内存大小 8192K * 25% = 2048K = 2M。

看到这里我们应该明白了，新创建的对象确实是优先存储于年轻代（YoungGen）中的Eden区的。

2. 大对象直接进入老年代

我们在进行上一知识点讲解时提到过，新创建的对象是优先存放入 Eden 区的，那么对于新创建的大对象来说，会直接进入老年代码。

什么是大对象：2M 的对象算大吗？10M 的对象算大吗？100M 的对象呢？什么是大对象，大对象的标准是什么？大对象的标准是可以由开发者定义的，我们的 JVM 参数中，能够通过 -XX：PretenureSizeThreshold 这个参数设置大对象的标准，可惜的是这个参数只对 Serial 和 ParNew 两款新生代收集器有效。

那么如果不能够设置 -XX：PretenureSizeThreshold 参数，那什么是大对象呢？Eden 区容量不够存放的对象就是所谓的大对象。

为了验证“大对象直接进入老年代”这一结论，我们依然通过实验进行验证。

实验设计：

• 沿用上一个实验的 JVM 参数设置，并在此基础上增加参数设置 -XX：PretenureSizeThreshold = 3m；
• 将新建的 2M 对象修改为新建 6M对象；
• 运行 main 函数，观察日志结果。

实验要点准备：本实验所需的 JVM 参数为 -Xms20m -Xmx20m -Xmn10m -XX:+PrintGCDetails。

代码示例：

public class DemoTest {
    public static void main(String[] args) {
        byte[] obj = new byte[6*1024*1024];
    }
}

运行结果：

Heap
 PSYoungGen      total 9216K, used 2370K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
  eden space 8192K, 28% used [0x00000000ff600000,0x00000000ff850aa0,0x00000000ffe00000)
  from space 1024K, 0% used [0x00000000fff00000,0x00000000fff00000,0x0000000100000000)
  to   space 1024K, 0% used [0x00000000ffe00000,0x00000000ffe00000,0x00000000fff00000)
 ParOldGen       total 10240K, used 6020K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  object space 10240K, 58% used [0x00000000fec00000,0x00000000ff1e1010,0x00000000ff600000)
 Metaspace       used 3439K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 374K, capacity 388K, committed 512K, reserved 1048576K
代码块123456789

结果分析：我们先来看下老年代（OldGen），total 10240K, used 6020K，说明我们新创建的对象是直接进入了老年代。然后我们来看下 Eden区 为什么不能存储 6M 大小的对象，我们进行简单的计算。

Eden 区剩余内存空间 = 总空间 8192K * （1-28%）= 5898 K < 6M。这就是我们所说的，大对象直接进入老年代。

3. 对象转移流程

上文我们学习了 Eden 区优先存放新建的独享，新建大对象不会经过Eden区，直接进入老年代，那么还剩两个区域没有进行讲解：幸存者区 from space 和 幸存者区 to space。我们在对流程图进行讲解时，会对这两块内存区域进行说明。

从上图中可以看出，新生成的非大对象首先放到年轻代 Eden 区，当 Eden 空间满了，触发 Minor GC，存活下来的对象移动到 Survivor0 区，Survivor0 区满后触发执行 Minor GC，Survivor0 区存活对象移动到 Suvivor1 区，这样保证了一段时间内总有一个 survivor 区为空。经过多次 Minor GC 仍然存活的对象移动到老年代。

如果新生成的是大对象，会直接将该对象存放入老年代。

老年代存储长期存活的对象，GC 期间会停止所有线程等待 GC 完成，所以对响应要求高的应用尽量减少发生 Major GC，避免响应超时。

4. 对象年龄判断

对象年龄判断的作用：JVM 通过判断对象的具体年龄来判别是否该对象应存入老年代，JVM通过对年龄的判断来完成从对象从年轻代到老年代的转移。

对象年龄（Age）计数器：HotSpot 虚拟机中多数收集器都采用了分代收集来管理堆内存，那内存回收时就必须能决策哪些存活对象应当放在新生代，哪些存活对象放在老年代中。为做到这点，虚拟机给每个对象定义了一个对象年龄（Age）计数器，存储在对象头中。

年龄增加：对象通常在 Eden 区里诞生，如果经过第一次 Minor GC 后仍然存活，并且能被Survivor容纳的话，该对象会被移动到 Survivor 空间中，并且将其对象年龄设为 1 岁。对象在Survivor区中每熬过一次 Minor GC，年龄就增加 1 岁。

年龄默认阈值：当它的年龄增加到一定程度（默认为15），就会被晋升到老年代中。对象晋升老年代的年龄阈值，可以通过参数 -XX：MaxTenuringThreshold 设置。