JVM的基本结构及JVM的内存溢出方式
2017-02-09 17:54
316 查看
JVM内部结构图
![](http://img.blog.csdn.net/20170209174910443?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc2hlbmhvbmdsZWkxMjM0/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
Java虚拟机主要分为五个区域:方法区、堆、Java栈、PC寄存器、本地方法栈。下面
来看一些关于JVM结构的重要问题。
1.哪些区域是共享的?哪些是私有的?
Java栈、本地方法栈、程序计数器是随用户线程的启动和结束而建立和销毁的,
每个线程都有独立的这些区域。而方法区、堆是被整个JVM进程中的所有线程共享的。
![](http://img.blog.csdn.net/20170209175423633?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc2hlbmhvbmdsZWkxMjM0/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
2.方法区保存什么?会被回收吗?
方法区不是只保存的方法信息和代码,同时在一块叫做运行时常量池的子区域还
保存了Class文件中常量表中的各种符号引用,以及翻译出来的直接引用。通过堆中
的一个Class对象作为接口来访问这些信息。
虽然方法区中保存的是类型信息,但是也是会被回收的,只不过回收的条件比较苛刻:
(1)该类的所有实例都已经被回收
(2)加载该类的ClassLoader已经被回收
(3)该类的Class对象没有在任何地方被引用(包括Class.forName反射访问)
3.方法区中常量池的内容不变吗?
方法区中的运行时常量池保存了Class文件中静态常量池中的数据。除了存放这些编译时
生成的各种字面量和符号引用外,还包含了翻译出来的直接引用。但这不代表运行时常量池
就不会改变。比如运行时可以调用String的intern方法,将新的字符串常量放入池中。
package com.cdai.jvm;
public class RuntimeConstantPool {
public staticvoid main(String[] args) {
String s1 = newString("hello");
String s2 = newString("hello");
System.out.println("Beforeintern, s1 == s2: " + (s1 == s2));
s1 =s1.intern();
s2 =s2.intern();
System.out.println("After intern, s1 == s2: " + (s1 == s2));
}
}
4.所有的对象实例都在堆上分配吗?
随着逃逸分析技术的逐渐成熟,栈上分配、标量替换优化技术使得“所有对象都分配
在堆上”也变得不那么绝对。
所谓逃逸就是当一个对象的指针被多个方法或线程引用时,我们称这个指针发生逃逸。
一般来说,Java对象是在堆里分配的,在栈中只保存了对象的指针。假设一个局部变量
在方法执行期间未发生逃逸(暴露给方法外),则直接在栈里分配,之后继续在调用栈
里执行,方法执行结束后栈空间被回收,局部变量就也被回收了。这样就减少了大量临时
对象在堆中分配,提高了GC回收的效率。
另外,逃逸分析也会对未发生逃逸的局部变量进行锁省略,将该变量上拥有的锁省略掉。
启用逃逸分析的方法时加上JVM启动参数:-XX:+DoEscapeAnalysis?EscapeAnalysisTest。
5.访问堆上的对象有几种方式?
(1)指针直接访问
栈上的引用保存的就是指向堆上对象的指针,一次就可以定位对象,访问速度比较快。
但是当对象在堆中被移动时(垃圾回收时会经常移动各个对象),栈上的指针变量的值
也需要改变。目前JVM HotSpot采用的是这种方式。
![](http://img.blog.csdn.net/20170209175122960?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc2hlbmhvbmdsZWkxMjM0/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
(2)句柄间接访问
栈上的引用指向的是句柄池中的一个句柄,通过这个句柄中的值再访问对象。因此句柄
就像二级指针,需要两次定位才能访问到对象,速度比直接指针定位要慢一些,但是当
对象在堆中的位置移动时,不需要改变栈上引用的值。
![](http://img.blog.csdn.net/20170209175252315?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc2hlbmhvbmdsZWkxMjM0/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
JVM内存溢出的方式
了解了Java虚拟机五个内存区域的作用后,下面我们来继续学习下在什么情况下
这些区域会发生溢出。
1.虚拟机参数配置
-Xms:初始堆大小,默认为物理内存的1/64(<1GB);默认(MinHeapFreeRatio参数可以调整)空余堆内存小于40%时,JVM就会增大堆直到-Xmx的最大限制。
-Xmx:最大堆大小,默认(MaxHeapFreeRatio参数可以调整)空余堆内存大于70%时,JVM会减少堆直到
-Xms的最小限制。
-Xss:每个线程的堆栈大小。JDK5.0以后每个线程堆栈大小为1M,以前每个线程堆栈大小为256K。应根据应用的线程所需内存大小进行适当调整。在相同物理内存下,减小这个值能生成更多的线程。但是操作系统对一个进程内的线程数还是有限制的,不能无限生成,经验值在3000~5000左右。一般小的应用,如果栈不是很深,应该是128k够用的,大的应用建议使用256k。这个选项对性能影响比较大,需要严格的测试。
-XX:PermSize:设置永久代(perm gen)初始值。默认值为物理内存的1/64。
-XX:MaxPermSize:设置持久代最大值。物理内存的1/4。
2.方法区溢出
因为方法区是保存类的相关信息的,所以当我们加载过多的类时就会导致方法区
溢出。在这里我们通过JDK动态代理和CGLIB代理两种方式来试图使方法区溢出。
2.1 JDK动态代理
package com.cdai.jvm.overflow;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class MethodAreaOverflow {
static interfaceOOMInterface {
}
static classOOMObject implements OOMInterface {
}
static classOOMObject2 implements OOMInterface {
}
public staticvoid main(String[] args) {
final OOMObjectobject = new OOMObject();
while (true) {
OOMInterfaceproxy = (OOMInterface) Proxy.newProxyInstance(
Thread.currentThread().getContextClassLoader(),
OOMObject.class.getInterfaces(),
newInvocationHandler() {
@Override
publicObject invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("Interceptor1is working");
return method.invoke(object, args);
}
}
);
System.out.println(proxy.getClass());
System.out.println("Proxy1: " + proxy);
OOMInterface proxy2= (OOMInterface) Proxy.newProxyInstance(
Thread.currentThread().getContextClassLoader(),
OOMObject.class.getInterfaces(),
newInvocationHandler() {
@Override
publicObject invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("Interceptor2 is working");
return method.invoke(object, args);
}
}
);
System.out.println(proxy2.getClass());
System.out.println("Proxy2: " + proxy2);
}
}
}
虽然我们不断调用Proxy.newInstance()方法来创建代理类,但是JVM并没有内存溢出。
每次调用都生成了不同的代理类实例,但是代理类的Class对象没有改变。是不是Proxy
类对代理类的Class对象有缓存?具体原因会在之后的《JDK动态代理与CGLIB》中进行
详细分析。
2.2 CGLIB代理
CGLIB同样会缓存代理类的Class对象,但是我们可以通过配置让它不缓存Class对象,
这样就可以通过反复创建代理类达到使方法区溢出的目的。
package com.cdai.jvm.overflow;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class MethodAreaOverflow2 {
static classOOMObject {
}
public staticvoid main(String[] args) {
while (true) {
Enhancerenhancer = new Enhancer();
enhancer.setSuperclass(OOMObject.class);
enhancer.setUseCache(false);
enhancer.setCallback(new MethodInterceptor() {
@Override
publicObject intercept(Object obj, Method method,
Object[] args, MethodProxy proxy) throws Throwable {
returnmethod.invoke(obj, args);
}
});
OOMObjectproxy = (OOMObject) enhancer.create();
System.out.println(proxy.getClass());
}
}
}
3.堆溢出
堆溢出比较简单,只需通过创建一个大数组对象来申请一块比较大的内存,就可以使
堆发生溢出。
package com.cdai.jvm.overflow;
public class HeapOverflow {
private staticfinal int MB = 1024 * 1024;
@SuppressWarnings("unused")
public staticvoid main(String[] args) {
byte[]bigMemory = new byte[1024 * MB];
}
}
4.栈溢出
栈溢出也比较常见,有时我们编写的递归调用没有正确的终止条件时,就会使方法不断
递归,栈的深度不断增大,最终发生栈溢出。
package com.cdai.jvm.overflow;
public class StackOverflow {
private staticint stackDepth = 1;
public staticvoid stackOverflow() {
stackDepth++;
stackOverflow();
}
public staticvoid main(String[] args) {
try {
stackOverflow();
}
catch(Exception e) {
System.err.println("Stack depth: " + stackDepth);
e.printStackTrace();
}
}
}
Java虚拟机主要分为五个区域:方法区、堆、Java栈、PC寄存器、本地方法栈。下面
来看一些关于JVM结构的重要问题。
1.哪些区域是共享的?哪些是私有的?
Java栈、本地方法栈、程序计数器是随用户线程的启动和结束而建立和销毁的,
每个线程都有独立的这些区域。而方法区、堆是被整个JVM进程中的所有线程共享的。
2.方法区保存什么?会被回收吗?
方法区不是只保存的方法信息和代码,同时在一块叫做运行时常量池的子区域还
保存了Class文件中常量表中的各种符号引用,以及翻译出来的直接引用。通过堆中
的一个Class对象作为接口来访问这些信息。
虽然方法区中保存的是类型信息,但是也是会被回收的,只不过回收的条件比较苛刻:
(1)该类的所有实例都已经被回收
(2)加载该类的ClassLoader已经被回收
(3)该类的Class对象没有在任何地方被引用(包括Class.forName反射访问)
3.方法区中常量池的内容不变吗?
方法区中的运行时常量池保存了Class文件中静态常量池中的数据。除了存放这些编译时
生成的各种字面量和符号引用外,还包含了翻译出来的直接引用。但这不代表运行时常量池
就不会改变。比如运行时可以调用String的intern方法,将新的字符串常量放入池中。
package com.cdai.jvm;
public class RuntimeConstantPool {
public staticvoid main(String[] args) {
String s1 = newString("hello");
String s2 = newString("hello");
System.out.println("Beforeintern, s1 == s2: " + (s1 == s2));
s1 =s1.intern();
s2 =s2.intern();
System.out.println("After intern, s1 == s2: " + (s1 == s2));
}
}
4.所有的对象实例都在堆上分配吗?
随着逃逸分析技术的逐渐成熟,栈上分配、标量替换优化技术使得“所有对象都分配
在堆上”也变得不那么绝对。
所谓逃逸就是当一个对象的指针被多个方法或线程引用时,我们称这个指针发生逃逸。
一般来说,Java对象是在堆里分配的,在栈中只保存了对象的指针。假设一个局部变量
在方法执行期间未发生逃逸(暴露给方法外),则直接在栈里分配,之后继续在调用栈
里执行,方法执行结束后栈空间被回收,局部变量就也被回收了。这样就减少了大量临时
对象在堆中分配,提高了GC回收的效率。
另外,逃逸分析也会对未发生逃逸的局部变量进行锁省略,将该变量上拥有的锁省略掉。
启用逃逸分析的方法时加上JVM启动参数:-XX:+DoEscapeAnalysis?EscapeAnalysisTest。
5.访问堆上的对象有几种方式?
(1)指针直接访问
栈上的引用保存的就是指向堆上对象的指针,一次就可以定位对象,访问速度比较快。
但是当对象在堆中被移动时(垃圾回收时会经常移动各个对象),栈上的指针变量的值
也需要改变。目前JVM HotSpot采用的是这种方式。
(2)句柄间接访问
栈上的引用指向的是句柄池中的一个句柄,通过这个句柄中的值再访问对象。因此句柄
就像二级指针,需要两次定位才能访问到对象,速度比直接指针定位要慢一些,但是当
对象在堆中的位置移动时,不需要改变栈上引用的值。
JVM内存溢出的方式
了解了Java虚拟机五个内存区域的作用后,下面我们来继续学习下在什么情况下
这些区域会发生溢出。
1.虚拟机参数配置
-Xms:初始堆大小,默认为物理内存的1/64(<1GB);默认(MinHeapFreeRatio参数可以调整)空余堆内存小于40%时,JVM就会增大堆直到-Xmx的最大限制。
-Xmx:最大堆大小,默认(MaxHeapFreeRatio参数可以调整)空余堆内存大于70%时,JVM会减少堆直到
-Xms的最小限制。
-Xss:每个线程的堆栈大小。JDK5.0以后每个线程堆栈大小为1M,以前每个线程堆栈大小为256K。应根据应用的线程所需内存大小进行适当调整。在相同物理内存下,减小这个值能生成更多的线程。但是操作系统对一个进程内的线程数还是有限制的,不能无限生成,经验值在3000~5000左右。一般小的应用,如果栈不是很深,应该是128k够用的,大的应用建议使用256k。这个选项对性能影响比较大,需要严格的测试。
-XX:PermSize:设置永久代(perm gen)初始值。默认值为物理内存的1/64。
-XX:MaxPermSize:设置持久代最大值。物理内存的1/4。
2.方法区溢出
因为方法区是保存类的相关信息的,所以当我们加载过多的类时就会导致方法区
溢出。在这里我们通过JDK动态代理和CGLIB代理两种方式来试图使方法区溢出。
2.1 JDK动态代理
package com.cdai.jvm.overflow;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class MethodAreaOverflow {
static interfaceOOMInterface {
}
static classOOMObject implements OOMInterface {
}
static classOOMObject2 implements OOMInterface {
}
public staticvoid main(String[] args) {
final OOMObjectobject = new OOMObject();
while (true) {
OOMInterfaceproxy = (OOMInterface) Proxy.newProxyInstance(
Thread.currentThread().getContextClassLoader(),
OOMObject.class.getInterfaces(),
newInvocationHandler() {
@Override
publicObject invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("Interceptor1is working");
return method.invoke(object, args);
}
}
);
System.out.println(proxy.getClass());
System.out.println("Proxy1: " + proxy);
OOMInterface proxy2= (OOMInterface) Proxy.newProxyInstance(
Thread.currentThread().getContextClassLoader(),
OOMObject.class.getInterfaces(),
newInvocationHandler() {
@Override
publicObject invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("Interceptor2 is working");
return method.invoke(object, args);
}
}
);
System.out.println(proxy2.getClass());
System.out.println("Proxy2: " + proxy2);
}
}
}
虽然我们不断调用Proxy.newInstance()方法来创建代理类,但是JVM并没有内存溢出。
每次调用都生成了不同的代理类实例,但是代理类的Class对象没有改变。是不是Proxy
类对代理类的Class对象有缓存?具体原因会在之后的《JDK动态代理与CGLIB》中进行
详细分析。
2.2 CGLIB代理
CGLIB同样会缓存代理类的Class对象,但是我们可以通过配置让它不缓存Class对象,
这样就可以通过反复创建代理类达到使方法区溢出的目的。
package com.cdai.jvm.overflow;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class MethodAreaOverflow2 {
static classOOMObject {
}
public staticvoid main(String[] args) {
while (true) {
Enhancerenhancer = new Enhancer();
enhancer.setSuperclass(OOMObject.class);
enhancer.setUseCache(false);
enhancer.setCallback(new MethodInterceptor() {
@Override
publicObject intercept(Object obj, Method method,
Object[] args, MethodProxy proxy) throws Throwable {
returnmethod.invoke(obj, args);
}
});
OOMObjectproxy = (OOMObject) enhancer.create();
System.out.println(proxy.getClass());
}
}
}
3.堆溢出
堆溢出比较简单,只需通过创建一个大数组对象来申请一块比较大的内存,就可以使
堆发生溢出。
package com.cdai.jvm.overflow;
public class HeapOverflow {
private staticfinal int MB = 1024 * 1024;
@SuppressWarnings("unused")
public staticvoid main(String[] args) {
byte[]bigMemory = new byte[1024 * MB];
}
}
4.栈溢出
栈溢出也比较常见,有时我们编写的递归调用没有正确的终止条件时,就会使方法不断
递归,栈的深度不断增大,最终发生栈溢出。
package com.cdai.jvm.overflow;
public class StackOverflow {
private staticint stackDepth = 1;
public staticvoid stackOverflow() {
stackDepth++;
stackOverflow();
}
public staticvoid main(String[] args) {
try {
stackOverflow();
}
catch(Exception e) {
System.err.println("Stack depth: " + stackDepth);
e.printStackTrace();
}
}
}
相关文章推荐
- 了解Java虚拟机JVM的基本结构及JVM的内存溢出方式
- JVM内存溢出的方式
- [转]JVM内存溢出的几种方式比较
- JVM内核学习 --内存相关,内存结构, GC,ClassLoader,内存溢出
- JVM内存溢出的方式
- JVM学习笔记(1、 基本结构;2、Java代码编译和执行的整个过程3、内存管理和垃圾回收 4、 内存调优 )
- JVM的基本结构和JVM的内存结构
- 数据结构基础——内存中数据存储的基本方式(单链表)
- JVM启动流程, JVM基本结构 ,内存模型,编译和解释运行的概念
- 【Java面试整理之JVM】深入理解JVM结构、类加载机制、垃圾回收GC原理、JVM内存分配策略、JVM内存泄露和溢出
- 概览JVM的基本结构和JVM内存结构
- jvm常见运行时内存溢出实现方式
- JVM内存溢出的方式
- JVM内存溢出的方式
- JVM内存结构及java相关基础知识
- JVM 深入笔记(2)内存溢出场景模拟
- 一次学会,jvm内存不再溢出
- JVM 深入笔记(2)内存溢出场景模拟
- Java中的OutOfMemoryError和JVM内存结构
- JVM内存大小配置方式