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

1.程序计数器

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

此内存区域是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。

2.Java虚拟机栈

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

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

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

  • 如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常；

​ 在单线程中，使用-Xss参数减少栈内存容量或者定义大量的本地变量，增大此方法帧中本地变量表的长度。结果将抛出StackOverflowError异常，异常出现时输出的堆栈深度响应缩小。

虚拟机栈StackOverflowError异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * VM args: -Xss128k
 */
public class JavaVMStackSOF {
 	private int stackLength = 1;
 	public void stackLeak() {
 		stackLength++;
 		stackLeak();
 	}
 	public static void main(String[] args) throws Throwable {
 		JavaVmStackSOF sof = new JavaVmStackSOF();
 		try {
 			sof.stackLeak();
 		} catch (Throwable e) {
 			System.out.println("stack length:" + sof.stackLength);
 			throw e;			
 		}
 	}
}
  • 如果虚拟机栈可以动态扩展，如果扩展时无法申请到足够的内存，将会抛出OutOfMemoryError异常。

​ 通过不断建立线程的方式会产生内存溢出异常，因为虚拟机栈是线程私有的，不断创建线程需要不断的分配虚拟机栈内存。每个线程分配到的栈容量越大，可以建立的线程数量自然就越少，建立线程时越容易把剩下的内存耗尽。如果是建立过多的线程导致的内存溢出，在不能减少线程数或者更换64位虚拟机的情况下，就只能通过减少最大堆（-Xmx）和减少栈容量（-Xss）来换取更多的线程。

创建线程导致内存溢出异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * VM args: -Xms20m -Xmx 20m -XX:+HeapDumpOnOutOfMemoryError
 */
public class JavaVMStackOOM {
    private void dontStop() {
        while (true) {}
    }
    public void stackLeakByThread() {
        while (true) {
            Thread thread = new Thread(new Runable() {
                @Override
                public void run() {
                    dontStop();
                }
            });
            thread.start();
        }
    }
    public static void main(String[] args) throws Throwable {
        JavaVMStackOOM oom = new JavaVMStackOOM();
        oom.stackLeakByThread();
    }
}

3.本地方法栈

虚拟机栈为Java方法（也就是字节码）服务，而本地方法栈则为虚拟机使用到的Native方法服务。
在虚拟机规范中对本地方法栈中方法使用的语言、使用方式与数据结构并没有强制规定，因此具体的虚拟机可以自由实现它。
与虚拟机栈一样，本地方法栈区域也会抛出StackOverflowError和OutOfMemory异常。

4.Java堆

对于大多数应用来说，Java堆是Java虚拟机所管理的内存中最大的一块。Java堆是被所有线程共享的一块内存区域，在虚拟机启动是创建。
此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都要在这里分配内存。
Java堆是垃圾收集器管理的主要区域，因此很多时候也被称作“GC堆”（Garbage Collected Heap）。
Java堆可以处于物理上不连续的内存空间，只要逻辑上是连续的即可，就像我们的磁盘空间一样。
在实现时，既可以实现成固定大小的，也可以是可扩展的，不过当前主流的虚拟机都是按照可扩展来实现的（通过-Xmx和-Xms控制）。
如果再堆中没有内存进行实例分配，并且堆也无法再扩展时，将会抛出OutOfMemoryError异常。

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

Java堆内存溢出异常测试

1
2
3
4
5
6
7
8
9
10
11
12
/**
 * VM args: -Xms20m -Xmx 20m -XX:+HeapDumpOnOutOfMemoryError
 */
public class HeapOOM {
 	static class OOMObject {}
 	public static void main(String[] args) {
 		List<OOMObject> list = new ArrayList<>();
 		while (true) {
 			list.add(new OOMObjects());
 		}
 	}
}

5.方法区

方法区和Java堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即使编译器编译后的代码等数据。
当方法区无法满足内存分配需求时，将抛出OutOfMemoryError异常。

方法区用于存放Class的相关信息，如类名、访问修饰符、常量池、字段描述、方法描述等等。在此借助CGLib直接操作字节码运行时生成大量的动态类，填满方法区，使其内存溢出。

借助CGLib使方法区出现内存溢出异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * VM args: -XX:PermSize=10M -XX:MaxPermSize=10M
 */
public class JavaMethodAreaOOM {
	static class OOMObject {}
    public static void main(String[] args) {
        while (true) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(OOMObject.class);
            enhancer.setUseCache(false);
            enhancer.setCallback(new MethodInterceptor() {
                public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                    retuen proxy.invokeSuper(obj, args);
                }
            });
            enhancer.create;
        }
    }
}

6.运行时常量池

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

字面量：文本字符串、声明为final的常量值等；
符号引用：类和接口的完全限定名、字段的名称和描述符、方法的名称和描述符

运行时常量池相对于Class文件常量池的另外一个重要特征是具备动态性，运行期间可以将新的常量放入池中（String类的intern()方法）
当常量池无法再申请到内存时会抛出OutOfMemoryError异常。

运行时常量池导致的内存溢出异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * VM args: -XX:PermSize=10M -XX:MaxPermSize=10M
 */
public class RuntimeConstantPoolOOM {
    public static void main(String[] args) {
    	// 使用List保持着常量池引用，避免Full GC回收常量池行为
        List<String> list = new ArrayList<>();
        // 10M的PermSize在interger范围内足够产生OOM了
        int i = 0;
        while (true) {
            list.add(String.valuOf(i++).intern());
        }
    }
}

常量池的好处：
常量池是为了避免频繁的创建和销毁对象而影响系统性能，其实现了对象的共享。
例如字符串常量池，在编译阶段就把所有的字符串文字放到一个常量池中。
1.节省内存空间：常量池中所有相同的字符串常量被合并，只占用一个空间。
2.节省运行时间：比较字符串时，==比equals()快。对于两个引用变量，只用==判断引用是否相等，也就可以判断实际值是否相等。

双等号==的含义：
基本数据类型之间应用双等号，比较的是他们的数值。
引用类型之间应用双等号，比较的是他们在内存中的存放地址。

关于常量池的扩展：https://www.jianshu.com/p/c7f47de2ee80

7.直接内存

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

使用Unsafe分配本机内存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * VM args: -Xmx20M -XX:MaxDirectMemorySize=10M
 */
public class DirectMemoryOOM {
    private static final int _1MB = 1024 * 1024;
    public static void main(String[] args) throws Exception {
        Field unsafeField = Unsafe.class.getDeclaredFields()[0];
        unsafeField.setAccessible(true);
        Unsafe unsafe = (Unsafe) unsafeField.get(null);
        while (true) {
            unsafe.allocateMemory(_1MB);
        }
    }
}
参考文献：《深入理解Java虚拟机》（第2版）周志明 著