Java虚拟机：内存管理与执行引擎

一、Java技术体系

Sun官方所定义的Java技术体系包括以下几个组成部分：

• Java程序设计语言
• 各种硬件平台上的Java虚拟机
• Class文件格式
• Java API类库
• 来自商业机构和开源社区的第三方类库

JDK（Java Development Kit） —— 包括Java程序设计语言、Java虚拟机、Java API类库。JDK是用于支持Java程序开发的最小环境。

JRE（Jave Runtime Environment） —— 包括Java API类库中的Java SE API子集、Java虚拟机。JRE是支持Java程序运行的标准环境。

下图展示了Java技术体系所包含的内容，以及JDK和JRE所涵盖的范围：

按照技术所服务的领域来分，Java技术体系可以分为四个平台，分别是：

• Java Card：支持一些Java小程序（Applet）运行在小内存设备（如智能卡）上的平台。
• Java ME（Micro Edition）：支持Java程序运行在移动终端（手机、PDA）上的平台，对Java API有所精简，并加入了针对移动终端的支持。
• Java SE（Standard Edition）：支持面向桌面级应用（如Windows下的应用程序）的Java平台，提供了完整的Java核心API。
• Java EE（Enterprise Edition）：支持使用多层架构的企业应用的Java平台，除了提供Java SE API之外，还对其做了大量的扩充并提供了相关的部署支持。

二、Java技术未来

1. 模块化

模块化是解决应用系统与技术平台越来越复杂、越来越庞大问题的一个重要途径。站在整个软件工业化的高度来看，模块化是建立各种功能的标准件的前提。最近几年的OSGi技术的迅速发展、各个厂商在JCP中对模块化规范的激烈斗争，都能充分说明模块化技术的迫切和重要。

2. 混合语言

当单一的Java开发已经无法满足当前软件的复杂需求时，越来越多基于Java虚拟机的语言开发被应用到软件项目中，Java平台上的多语言混合编程正成为主流，每种语言都可以针对自己擅长的方面更好地解决问题。试想一下，在一个项目之中，并行处理用Clojure语言编写，展示层使用JRuby/Rails，中间层使用Java，每个应用层都将使用不同的编程语言来完成，而且，接口对每一层的开发者都是透明的，各种语言之间的交互不存在任何困难，就像使用自己语言的原生API一样方便，因为它们最终都运行在一个虚拟机之上。因此，整个JVM项目开始推动Java虚拟机从“Java语言的虚拟机”向“多语言虚拟机”的方向发展。

3. 多核并行

如今，CPU硬件的发展方向已经从高频率转变为多核心，随着多核时代的来临，软件开发越来越关注并行编程的领域。Fork/Join模式是处理并行编程的一个经典方法，通过利用Fork/Join模式，我们能够更加顺畅地过渡到多核时代。

在Java8中，将会提供Lambda支持，这将会极大地改善目前Java语言不适合函数式编程的现状。另外，在并行计算中必须提及的还有Sumatra项目，其主要关注为Java提供使用GPU和APU运算能力的工具。在JDK外围，也出现了专为满足并行计算需求的计算框架，如Apache的Hadoop Map/Reduce等。

4. 进一步丰富语法

Java 5曾经对Java语法进行了一次扩充，这次扩充加入了自动装箱、泛型、动态注解、枚举、可变长参数、遍历循环等语法，而后，每一次Java版本的发布，都会进一步丰富Java语言的语法特性，包括Java 8中的Lambda表达式。

5. 64位虚拟机

随着硬件的进一步发展，计算机终究会完全过渡到64位的时代，这是一件毫无疑问的事情，主流的虚拟机应用也终究会从32位发展到64位，而Java虚拟机对64位的支持也将会进一步完善。

二、Java内存管理机制

Java与C++之间有一堵由内存动态分配和垃圾收集技术所围成的高墙，墙外面的人想进去，墙里面的人却想出来。

1. 运行时数据区域

Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干不同的数据区域。这些区域都有各自的用途，以及创建和销毁的时间，有的区域随着虚拟机进程的启动而存在，有些区域则依赖于用户线程的启动和结束而建立和销毁。

Java虚拟机所管理的内存包括以下几个运行时数据区域：

1.1 程序计数器

程序计数器（Program Counter Register）是一块较小的内存空间，它可以看做是当前线程所执行的字节码的行号指示器。

在虚拟机的概念模型里，字节码解释器工作时就是通过改变程序计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖于程序计数器来完成。

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

如果线程正在执行的是一个Java方法，程序计数器记录的是正在执行的虚拟机字节码指令的地址；如果正在执行的是Native方法，则程序计数器的值为空（Undefined）。

程序计数器是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。

1.2 Java虚拟机栈

与程序计数器一样，Java虚拟机栈（Java Virtual Machine Stack）也是线程私有的，它的生命周期与线程相同。虚拟机栈描述的是Java方法执行的内存模型：每个方法在执行的同时都会创建一个栈帧（Stack Frame，栈帧是方法运行时的基础数据结构）用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。

对于C/C++等程序来说，其内存管理常常分为栈、堆等。对于Java，栈即指代虚拟机栈，或者说是虚拟机栈中局部变量表部分。

局部变量表存放了编译期可知的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不等同于对象本身，可能是一个指向对象起始地址的引用地址，也可能是指向一个代表对象的句柄或其他与此对象相关的位置）和returnAddress类型（指向了一条字节码指令的地址）。

局部变量表所需的内存空间在编译期间完成分配，当进入一个方法时，这个方法需要在帧中分配多大的局部变量空间是完全确定的，在方法运行期间不会改变局部变量表的大小。

可以通过 -Xss 这个虚拟机参数来指定一个程序的 Java 虚拟机栈内存大小：

java -Xss=512M HackTheJava

该区域可能抛出以下异常：

• 当线程请求的栈深度超过最大值，会抛出StackOverflowError 异常；
• 栈进行动态扩展时如果无法申请到足够内存，会抛出OutOfMemoryError 异常。

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

1.3 本地方法栈

本地方法栈（Native Method Stack）与虚拟机栈所发挥的作用是非常相似的，它们的区别是虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则为虚拟机使用到的Native方法服务。与虚拟机栈一样，本地方法栈也会抛出StackOverflowError异常和OutOfMemoryError异常。

1.4 Java堆

对于大多数应用来说，Java堆（Java Heap）是Java虚拟机所管理的内存中最大的一块。Java堆是被所有线程共享的一块内存区域，在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例。在JVM中，几乎所有的对象实例都在这里分配内存。Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配，但是随着JIT编译器的发展和逃逸技术逐渐成熟，栈上分配、标量替换优化技术将会导致一些微妙的变化发生，所有的对象都分配在堆上也变得不是那么绝对了。

Java堆是垃圾收集器管理的主要区域，因此，Java堆也被称为“GC堆”（Garbage Collected Heap）。

现代的垃圾收集器基本都是采用分代收集算法，该算法的思想是针对不同的对象采取不同的垃圾回收算法，因此虚拟机把Java堆分成以下三块：

• 新生代（Young Generation）
• 老年代（Old Generation）
• 永久代（Permanent Generation）

当一个对象被创建时，它首先进入新生代，之后有可能被转移到老年代中。新生代存放着大量的生命很短的对象，因此新生代在三个区域中垃圾回收的频率最高。为了更高效的进行垃圾回收，把新生代继续划分为以下三个空间：

• Eden
• From Survivor
• To Survivor

从内存分配的角度来看，线程共享的Java堆中可能划分出多个线程私有的分配缓冲区（Thread Local Allocation Buffer, TLAB）。根据Java虚拟机规范的规定，Java堆可以处于物理上不连续的内存空间，只要逻辑上是连续的即可。在实现时，既可以实现成固定大小的，也可以是可扩展的，如果在堆中没有内存完成实例分配，并且堆也无法再扩展时，将会抛出OutOfMemoryError异常。

可以通过 -Xms 和 -Xmx 两个虚拟机参数来指定一个程序的 Java 堆内存大小，第一个参数设置最小值，第二个参数设置最大值。

java -Xms=1M -XmX=2M HackTheJava

1.5 方法区

方法区（Method Area）与Java堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做Non-Heap（非堆），目的应该与Java堆区分开来。

Java虚拟机规范对方法区的限制非常宽松，除了和Java堆一样不需要连续的内存和可以选择固定大小或者可扩展外，还可以选择不实现垃圾回收。相对而言，垃圾收集行为在这个区域是比较少出现的，但并非数据进入了方法区就如同永久代名字一样永久存在。该区域的内存回收目标主要是针对常量池的回收和对类型的卸载。

根据Java虚拟机规范的规定，当方法区无法满足内存分配需求时，将抛出OutOfMemoryError异常。

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

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

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

1.6 直接内存

直接内存（Direct Memory）并不是虚拟机运行时数据区的一部分，也不是Java虚拟机规范中定义的内存区域。

在Java4中新加入的NIO类，其引入了一种基于通道与缓冲区的IO方式，它可以使用Native函数库直接分配堆外内存，然后通过一个存储在Java堆中的DirectByteBuffer对象作为这块内存的应用进行操作。这样能在一些场景中显著提高性能，在一定程度上能避免在Java堆和Native堆中来回复制数据。

2. JVM对象探秘

在本部分，我们将深入探讨HotSpot虚拟机在Java堆中对象分配、布局和访问的全过程。

2.1 对象的创建

在HotSpot虚拟机中，对象的创建过程分为五个步骤：

步骤一

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

步骤二

在类加载检查通过后，虚拟机将为新生对象分配内存。对象所需内存的大小在类加载完成后便可完全确定，为对象分配内存空间的任务等同于把一块确定大小的内存从Java堆中划分出来。分配方式有：

1. 指针碰撞（Bump the Pointer）：假设Java堆中内存是绝对规整的，即所有用过的内存都放在一边，空闲的内存放在另一边，中间放着一个指针作为分界点的指示器，指针碰撞的内存分配方式就是把作为分界点的指针向空闲空间挪动一段与对象大小相等的距离即可。

2. 空闲列表（Free List）：如果Java堆中的内存不是规整的，即已使用的内存和空闲的内存相互交错，那么就无法使用指针碰撞了。此时，虚拟机就必须维护一个列表，记录哪些内存块是可用的，于是，空闲列表的内存分配方式就是从该列表中找到一块足够大的空间划分给对象实例，并更新列表上的记录。

选择哪种内存分配方式由Java堆是否规整决定，而Java堆是否规整又由所采用的垃圾收集器是否带有压缩整理功能决定。因此，在使用Serial、ParNew等带Compact过程的收集器时，系统采用的分配算法是指针碰撞，而使用CMS这种基于Mark-Sweep算法的收集器时，通常采用空闲列表。

另外，在并发环境下，内存分配方式面临线程安全问题。解决这个问题有两种方案：

1. 对分配内存空间的动作进行同步处理——实际上虚拟机采用CAS结合失败重试的方法来保证更新操作的原子性。

2. 把内存分配的动作按照线程划分在不同的空间之中进行，即每个线程在Java堆中预先分配一小块内存，称为本地线程分配缓冲区（Thread Local Allocation Buffer，TLAB）。

步骤三

内存分配完成后，虚拟机需要将分配的内存空间初始化为零值（不包括对象头）。这一步操作保证了对象的实例字段在Java代码中可以不赋初值就直接使用，程序能访问到这些字段的数据类型所对应的零值。

步骤四

接下来，虚拟机要对对象进行必要的设置，例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码、对象的GC分代年龄等信息。这些信息存放在对象的对象头（Object Header）之中。

步骤五

在上面的工作都完成之后，从虚拟机的视角看，一个新的对象已经产生了。但是，从Java程序员的视角来看，对象创建才刚刚开始——方法还没有执行，所有字段都还为零。

因此，一般来说，执行new命令之后，会接着执行方法，把对象按照程序员的意愿进行初始化，这样，一个真正可用的对象才算完全产生出来。

2.2 对象内存布局

在HotSpot虚拟机中，对象在内存中存储的布局可以划分为3个区域：

• 对象头（Object Header）
• 实例数据（Instance Data）
• 对齐填充（Padding）

对象头信息

HotSpot虚拟机的对象头包括两部分信息：

• 第一部分：用于存储对象自身的运行时数据，如哈希码、GC分代年龄、锁状态标志、线程持有的锁等，官方称之为“Mark Word”。该部分数据长度在32位和64位虚拟机中分别为32位和64位。Mark Word被设计成一个非固定的数据结构，以便在极小的空间内存储尽量多的信息，它会根据对象的状态复用自己的存储空间。下表是32位HotSpot虚拟机对象头Mark Word。

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

• 第二部分：类型指针，即对象指向它的类元数据的指针，虚拟机通过该指针来确定这个对象是哪个类的实例。另外，如果对象是一个Java数组，那在对象头中还必须有一块用于记录数组长度的数据。

实例数据

实例数据部分是对象真正存储的有效信息，也是在程序代码中所定义的各种类型的字段内容。无论是从父类继承下来的，还是在子类中定义的，都需要记录下来。

该部分的存储顺序会受到虚拟机分配策略参数（FieldsAllocationStyle）和字段在Java源码中定义顺序影响。

• HotSpot虚拟机默认的分配策略为longs/doubles、ints、shorts/chars、bytes/booleans、oops（Ordinary Object Pointers）。从分配策略可以看出，相同宽度的字段总是分配在一起。在满足该前提条件下，在父类中定义的变量会出现在子类之前。

对齐填充

对齐填充并不是必然存在的，也没有特别的含义，它仅仅起着占位符的作用。当对象实例数据部分没有对齐时，需要通过对齐填充来补全。

3. OutOfMemoryError异常

3.1 Java堆溢出

Java堆配置参数：-Xmx 和 -Xms

Java堆用于存储对象实例，只要不断地创建对象，并且保证GC Roots到对象之间有可达路径来避免垃圾回收机制清除这些对象，那么在对象数量到达最大堆的容量限制后就会产生内存溢出异常。

测试代码：

public class HeapOOM {
    static classn OOMObject {
    }

    public static void main(String[] args) {
        List list = new ArrayList();

        while (true) {
            list.add(new OOMObject);
         }
    }
}

3.2 虚拟机栈和本地方法栈溢出

Java虚拟机栈配置参数：-Xss

关于虚拟机栈和本地方法栈，在Java虚拟机规范中描述了两种异常：

• 如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出StackOverflowError异常；
• 如果虚拟机在扩展栈时无法申请到足够的内存空间，将抛出OutOfMemoryError异常。

测试代码：

public class JavaVMStackSOF {
    private int stackLength = 1;

    public void stackLeak() {
        stackLength++;
        stackLeak();
    }

    public static void main(String[] args) {
        JavaVMStackSOF oom = new JavaVMStackSOF();

        try{
            oom.stackLeak();
        } catch(Throwable e) {
            System.out.println("stack length = " + oom.stackLength);
            throw e;
        }
    }
}

3.3 方法区和运行时常量池溢出

方法区配置参数：-XX:PermSize和-XX:MaxPermSize

String.intern()是一个Native方法，它的作用是：如果字符串常量池中已经包含一个等于此String对象的字符串，则返回代表池中这个字符串的String对象；否则，将此对象包含的字符串添加到常量池中，并且返回此String对象的引用。

测试代码：

public class RuntimeConstantPoolOOM {
    public static void main(String[] args) {
        List list = new ArrayList();
        int i = 0;
        while (true) {
            list.add(String.valueOf(i++).intern());
        }
    }
}

3.4 本机直接内存溢出

直接内存配置参数：-XX:MaxDirectMemorySize

三、Java垃圾回收机制

1. 对象存活判断及垃圾回收概述

GC需要完成三件事情：

• 哪些内存需要回收？
• 什么时候回收？
• 如何回收？

为什么需要去了解GC和内存分配呢？答案很简单：当需要排查各种内存溢出、内存泄露问题时，当垃圾收集成为系统达到更高并发量的瓶颈时，我们就需要对这些“自动化”的技术实施必要的监控和调节。

Java堆和方法区的内存的分配和回收是动态的，垃圾收集器主要关注的就是这部分内存。

对象存亡问题：在堆里面存放着Java世界中几乎所有的对象实例，垃圾收集器在对堆进行回收前，第一件事情就是要确定这些对象之中哪些还“存活”着，哪些已经“死去”（即不可能再被任何途径使用的对象）。

1.1 引用计数算法

引用计数算法：给对象添加一个引用计数器，每当有一个地方引用它时，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器为0的对象就是不可能再被使用的。

客观的说，引用计数算法（Reference Counting）实现简单，判定效率也很高。但Java虚拟机并没有选用引用计数算法来管理内存，最主要的原因是引用计数算法很难解决对象间相互循环引用的问题。

1.2 可达性分析算法

在主流的商用程序语言中（Java、C#）的主流实现中，都是通过可达性分析（Reachability Analysis）来判定对象是否存活的。

可达性分析算法：通过一系列的称为“GC Roots”的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链（Reference Chain），当一个对象到GC Roots没有任何引用链接相连（用图论的话来说，就是从GC Roots到这个对象不可达）时，则证明该对象是不可用的。

在Java语言中，可作为GC Roots的对象包括下面几种：

• 虚拟机栈（栈帧中的本地变量表）中引用的对象；
• 方法区中类静态属性引用的对象；
• 方法区中常量引用的对象；
• 本地方法栈中JNI（Native方法）引用的对象。

1.3 引用类型

无论是通过引用计算算法判断对象的引用数量，还是通过可达性分析算法判断对象的引用链是否可达，判定对象是否存活都与“引用”有关。

Java 对引用的概念进行了扩充，引入四种强度不同的引用类型。

强引用

只要强引用存在，垃圾回收器永远不会回收调掉被引用的对象。

使用 new 一个新对象的方式来创建强引用。

Object object = new Object();

软引用

用来描述一些还有用但是并非必需的对象。

在系统将要发生内存溢出异常之前，将会对这些对象列进回收范围之中进行第二次回收。如果这次回收还没有足够的内存，才会抛出溢出异常。

软引用主要用来实现类似缓存的功能，在内存足够的情况下直接通过软引用取值，无需从繁忙的真实来源获取数据，提升速度；当内存不足时，自动删除这部分缓存数据，从真正的来源获取这些数据。

使用 SoftReference 类来实现软引用。

Object obj = new Object();
SoftReference