JVM 学习笔记1 JAVA内存区域与溢出异常

一、 运行时数据区

图 HotShot虚拟机内存模型

1、 程序计数器（Program Counter Register）

线程隔离的数据区

内容：

一块比较小的内存空间
可以看作当前线程所执行的字节码的行号指示器

异常：

唯一一个在 java虚拟机中没有规定任何OutOfMemoryError情况的区域

2、 Java虚拟机栈(Java Virtual Machine Stacks)

线程隔离的数据区
生命周期与线程相同

内容：

描述的是Java方法执行的内存模型：每个方法被执行的时候都会同时创建一个栈帧用于存储局部变量表、操作栈、动态链接、方法出口等信息。每个方法被调用直到执行完成的过程，就对应着一个栈帧在虚拟机中从入栈到出栈的过程。

局部变量表：

各种基本数据类型：boolean、byte、char、short、int、float、long、double
对象引用（reference类型，不等同于对象本身，根据不同虚拟机的实现，可能是指向对象起始地址的引用指针，也可能指向一个代表对象的句柄或其他与此对象相关的位置）
returnAddress类型：指向了一条字节码指令的地址

局部变量表所需的内存空间在编译期间完成分配

参数：

-Xss：栈容量

异常：

StackOverflowError：如果线程请求的栈深度大于虚拟机所允许的深度，将抛出此异常
OutOfMemoryError：如果虚拟机栈可以动态扩展，当扩展时无法申请到足够的内存时抛出此异常
（这两种异常存在一些重叠之处，当栈空间无法继续分配时，到底是内存太小，还是已使用的栈空间太大）

3、 本地方法栈（Native Method Stacks）

为虚拟机使用到的Native方法服务
有的JVM将本地方法栈和虚拟机栈合并在一起（如HotSpot）

参数：

-Xoss：本地方法区大小（非HotSpot虚拟机使用）
-MaxPermSize：最大方法区容量

异常：

StackOverflowError
OutOfMemoryError

4、 Java堆（Java Heap）

所有线程共享的一块内存区域
在虚拟机启动时创建

内容：

此内存的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。

参数：

-Xms：堆的最小值
-Xmx：堆的最大值（-Xms与-Xmx设置为一样时，堆不自动扩展）

异常：

OutOfMemoryError：如果在堆中没有内存完成实例分配，并且堆也无法在扩展时，将会抛出此异常。

5、 方法区（Method Area）

所有线程共享的内存区域
堆的一个逻辑部分，但它的别名叫None Heap（非堆）：堆是Java程序员使用的，存放对象；非堆是JVM使用的，存放类信息

内容：

存储已被虚拟机加载的类信息、常量、静态变量、即使编译器编译后的代码

参数：

-XX:PermSize：
-XX:MaxPermSize：

异常：

OutOfMemoryError：当方法区无法满足内存分配需求时，将会抛出此异常。

5.1 运行时常量池（Runtime Constant Pool）

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

6、 直接内存（Direct Memory）

不是虚拟机运行时数据区的一部分，也不是Java虚拟机规范中定义的内存区域。

在JDK 1.4中新加入了NIO（New Input/Output）类，引入了一种基于通道（Channel）与缓冲区（Buffer）的I/O方式，它可以使用Native函数库直接分配堆外内存，然后通过一个存储在Java堆里面的DirectByteBuffer对象作为这块内存的引用进行操作。

本机直接内存的分配不会受到Java堆大小的限制。

参数：

-XX:MaxDirectMemorySize：直接内存的容量，如果不指定，则默认为java堆的最大值（-Xmx指定）

异常：

OutOfMemoryError

二、 对象访问

Object obj = new Object() ;

”Object obj“：反映到Java栈的本地变量表中，作为一个reference类型的数据出现。

“new Object()”：反映到Java堆中，形成一个存储了Object类型所有实例数据值的结构化内存。还有包含能查找到此对象类型数据的地址信息，这部分数据存储在方法区。

在Java虚拟机规范中，reference类型有两种访问对象的方式：

1、使用句柄访问方式：





2、使用直接指针访问方式：

三、 实战：OutOfMemoryError异常

1、 Java堆溢出

package jvm.memory;

import java.util.ArrayList;
import java.util.List;

/**
* <code>{@link HeapOOM}</code>
*
* 测试Java堆溢出
* OOM -> OutOfMemoryError
*
* VM Args:-Xms20m -Xmx20m -XX:+HeapDumpOnOutOfMemoryError
*
* @author yameing
*/
public class HeapOOM {

static class OOMObject {
int i = 1 ;
}

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

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

}

}

结果：

E:\Test\src>java -Xms20m -Xmx20m -XX:+HeapDumpOnOutOfMemoryError jvm.memory.HeapOOM
java.lang.OutOfMemoryError: Java heap space
Dumping heap to java_pid4236.hprof ...
Heap dump file created [28780941 bytes in 0.501 secs]
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at java.util.Arrays.copyOf(Arrays.java:2760)
at java.util.Arrays.copyOf(Arrays.java:2734)
at java.util.ArrayList.ensureCapacity(ArrayList.java:167)
at java.util.ArrayList.add(ArrayList.java:351)
at jvm.memory.HeapOOM.main(HeapOOM.java:31)

说明：

-XX:HeapDumpOnOutOfMemoryError：让虚拟机在出现内存溢出异常时，Dump出当前的内存堆转储快照

解决堆溢出异常：

通过内存映像分析工具（如Eclipse Memory Analyzer）对dump出来的堆存储快照进行分析，重点是确认内存中的对象是否是必要的，也就是要分清楚到底是出现了内存泄露（Memory Leak）还是内存溢出（Memory Overflow）。

内存泄露： 一般来说内存泄漏有两种情况。一种情况如在C/C++语言中的，在堆中的分配的内存，在没有将其释放掉的时候，就将所有能访问这块内存的方式都删掉（如指针重新赋值）；另一种情况则是在内存对象明明已经不需要的时候，还仍然保留着这块内存和它的访问方式（引用）。第一种情况，在Java中已经由于垃圾回收机制的引入，得到了很好的解决。所以，Java中的内存泄漏，主要指的是第二种情况。（无用的对象过多）

1、查看泄露对象到GC Roots的引用链
2、确定导致GC无法自动回收他们的原因

3、定位出泄露代码的位置
内存溢出：存在无法回收的内存或使用的内存过多，最终使得程序运行要用到的内存大于虚拟机能提供的最大内存。（有用的对象过多）
1、检查虚拟机的堆参数（-Xms与-Xmx）
2、检查是否某些对象生命周期过长

2、 虚拟机栈和本地方法栈溢出

由于HotSpot虚拟机中并不区分虚拟机栈和本地方法栈，因此对于HotSpot来说，-Xoss参数（设置本地方法栈大小）虽然存在，但实际上是无效的，栈容量只由-Xss参数设定。

a、虚拟机栈和本地方法栈StackOverFlow测试：

package jvm.memory;

/**
* <code>{@link JavaVMStackSOF}</code>
*
* 虚拟机栈和本地方法栈StackOverFlow测试
*
* VM Args:-Xss128k
*
* @author yameing
*/
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 (Exception e) {
System.out.println("stack length : " + oom.stackLength);
e.printStackTrace();
}
}

}

结果：

E:\Test\src>java -Xss128k jvm.memory.JavaVMStackSOF
stack length : 2401
Exception in thread "main" java.lang.StackOverflowError
at jvm.memory.JavaVMStackSOF.stackLeak(JavaVMStackSOF.java:22)
at jvm.memory.JavaVMStackSOF.stackLeak(JavaVMStackSOF.java:23)
at jvm.memory.JavaVMStackSOF.stackLeak(JavaVMStackSOF.java:23)

解决堆溢出异常：

出现StackOverFlow异常时有错误堆栈可以阅读，相对来说，比较容易找到问题的所在。

使用虚拟机默认参数，栈深度在大多数情况下，达到1000~2000完全没有问题，对于正常的调用，这个深度应该完全够用。

b、模拟虚拟机栈内存溢出：

package jvm.memory;

/**
* <code>{@link JavaVMStackOOM}</code>
*
* 模拟虚拟机栈内存溢出
* Args:-Xss2M
*
* @author Administrator
*/
public class JavaVMStackOOM {

/**
* 不断循环，不让线程结束
*/
public void donotStop() {
while(true) {}
}

/**
* 不断创建新线程
*/
public void stackLeakByThread() {
while(true) {
Thread t = new Thread(new Runnable() {

@Override
public void run() {
donotStop() ;
}

}) ;
t.start() ;
}
}

public static void main(String[] args) {
JavaVMStackOOM oom = new JavaVMStackOOM() ;
oom.stackLeakByThread() ;
}

}

结果：（此程序会导致操作系统假死）

E:\Test\src>java -Xss128k jvm.memory.JavaVMStackOOM
Exception in thread "main" java.lang.OutOfMemoryError:unable to create new native thread
at java.lang.Thread.start0(Native Method)
at java.lang.Thread.start(Thread.java:597)
at jvm.memory.JavaVMStackOOM.stackLeakByThread(JavaVMStackOOM.java:34)
at jvm.memory.JavaVMStackOOM.main(JavaVMStackOOM.java:40)

解析：

执行此示例程序时，指定栈内存容量为2M，栈内存为线程隔离的数据区，程序中不断创建新的线程，每个线程都分得一份2M的独享空间，当到达一定程度，程序运行要用到的栈内存大于操作系统分配给进程的内存，也就发生了内存溢出。

虚拟机栈内存 + 本地方法栈 = 操作系统分配给进程的内存 - Xmx（最大堆内存） - MaxPermSize(最大方法区容量) - 程序计数器容量- 虚拟机进程本身耗费的内存

最大线程数 = 虚拟机栈内存 / Xss

解决栈内存溢出：

在不能减少线程数的情况下，减少Xmx和减少Xss，来换取更多的线程。

3、 运行时常量池溢出：

package jvm.memory;

import java.util.List;
import java.util.ArrayList;

/**
* <code>{@link RuntimeConstantPoolOOM}</code>
*
* VM Args:-XX:PermSize=10M -XX:MaxPermSize=10M
*
* @author yameing
*/
public class RuntimeConstantPoolOOM {

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

}

结果：

E:Test\src>java -XX:PermSize=10M -XX:MaxPermSize=10M jvm.memory.RuntimeConstantPoolOOM
Exception in thread "main" java.lang.OutOfMemoryError: PermGen space
at java.lang.String.intern(Native Method)
at jvm.memory.RuntimeConstantPoolOOM.main(RuntimeConstantPoolOOM.java:26)

4、 方法区溢出：

参考tomcat重新加载应用时的溢出错误。

5、本机直接内存溢出：

package jvm.memory;

import java.lang.reflect.Field;

import sun.misc.Unsafe;

/**
* <code>{@link DirectMemoryOOM}</code>
*
* VM Args:-Xmx20M -XX:MaxDirectMemorySize=10M
*
* @author yameing
*/
public class DirectMemoryOOM {

private static final int _1MB = 1024 * 1024 ;

public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException {
Field unsafeField = Unsafe.class.getDeclaredFields()[0] ;
unsafeField.setAccessible(true) ;
Unsafe unsafe = (Unsafe) unsafeField.get(null) ;
while(true) {
unsafe.allocateMemory(_1MB) ;
}
}
}

结果：

E:\bingosoft\project\Test\src>java -Xmx20M -XX:MaxDirectMemorySize=10M jvm.memory.DirectMemoryOOM
Exception in thread "main" java.lang.OutOfMemoryError
at sun.misc.Unsafe.allocateMemory(Native Method)
at jvm.memory.DirectMemoryOOM.main(DirectMemoryOOM.java:28)