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;

/**
 * {@link HeapOOM}
 *
 * 测试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 list = new ArrayList() ;
        
        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;

/**
 * {@link JavaVMStackSOF}
 *
 * 虚拟机栈和本地方法栈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;

/**
 * {@link JavaVMStackOOM}
 *
 * 模拟虚拟机栈内存溢出
 * 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;

/**
 * {@link RuntimeConstantPoolOOM}
 *  
 * VM Args:-XX:PermSize=10M -XX:MaxPermSize=10M
 * 
 * @author yameing
 */
public class RuntimeConstantPoolOOM {
    
    public static void main(String[] args) throws Throwable {
        List list = new ArrayList() ;
        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;

/**
 * {@link DirectMemoryOOM}
 *
 * 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)