欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

了解Java虚拟机JVM的基本结构及JVM的内存溢出方式

程序员文章站 2024-03-08 22:19:04
jvm内部结构图 java虚拟机主要分为五个区域:方法区、堆、java栈、pc寄存器、本地方法栈。下面 来看一些关于jvm结构的重要问题。 1.哪些区域是共享...

jvm内部结构图

了解Java虚拟机JVM的基本结构及JVM的内存溢出方式

java虚拟机主要分为五个区域:方法区、堆、java栈、pc寄存器、本地方法栈。下面
来看一些关于jvm结构的重要问题。

1.哪些区域是共享的?哪些是私有的?

java栈、本地方法栈、程序计数器是随用户线程的启动和结束而建立和销毁的,
每个线程都有独立的这些区域。而方法区、堆是被整个jvm进程中的所有线程共享的。

了解Java虚拟机JVM的基本结构及JVM的内存溢出方式

2.方法区保存什么?会被回收吗?

方法区不是只保存的方法信息和代码,同时在一块叫做运行时常量池的子区域还
保存了class文件中常量表中的各种符号引用,以及翻译出来的直接引用。通过堆中
的一个class对象作为接口来访问这些信息。

虽然方法区中保存的是类型信息,但是也是会被回收的,只不过回收的条件比较苛刻:

(1)该类的所有实例都已经被回收

(2)加载该类的classloader已经被回收

(3)该类的class对象没有在任何地方被引用(包括class.forname反射访问)


3.方法区中常量池的内容不变吗?

方法区中的运行时常量池保存了class文件中静态常量池中的数据。除了存放这些编译时
生成的各种字面量和符号引用外,还包含了翻译出来的直接引用。但这不代表运行时常量池
就不会改变。比如运行时可以调用string的intern方法,将新的字符串常量放入池中。

package com.cdai.jvm; 
 
public class runtimeconstantpool { 
 
  public static void main(string[] args) { 
 
    string s1 = new string("hello"); 
    string s2 = new string("hello"); 
    system.out.println("before intern, 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采用的是这种方式。

了解Java虚拟机JVM的基本结构及JVM的内存溢出方式

(2)句柄间接访问

栈上的引用指向的是句柄池中的一个句柄,通过这个句柄中的值再访问对象。因此句柄
就像二级指针,需要两次定位才能访问到对象,速度比直接指针定位要慢一些,但是当
对象在堆中的位置移动时,不需要改变栈上引用的值。

了解Java虚拟机JVM的基本结构及JVM的内存溢出方式


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 interface oominterface { 
  } 
   
  static class oomobject implements oominterface { 
  } 
   
  static class oomobject2 implements oominterface { 
  } 
   
  public static void main(string[] args) { 
    final oomobject object = new oomobject(); 
    while (true) { 
      oominterface proxy = (oominterface) proxy.newproxyinstance( 
          thread.currentthread().getcontextclassloader(),  
          oomobject.class.getinterfaces(),  
          new invocationhandler() { 
            @override 
            public object invoke(object proxy, method method, object[] args) 
                throws throwable { 
              system.out.println("interceptor1 is 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(),  
          new invocationhandler() { 
            @override 
            public object 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 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() { 
        @override 
        public object intercept(object obj, method method, 
            object[] args, methodproxy proxy) throws throwable { 
          return method.invoke(obj, args); 
        } 
      }); 
      oomobject proxy = (oomobject) enhancer.create(); 
      system.out.println(proxy.getclass()); 
    } 
  } 
   
} 


3.堆溢出

堆溢出比较简单,只需通过创建一个大数组对象来申请一块比较大的内存,就可以使
堆发生溢出。

package com.cdai.jvm.overflow; 
 
public class heapoverflow { 
 
  private static final int mb = 1024 * 1024; 
   
  @suppresswarnings("unused") 
  public static void main(string[] args) { 
    byte[] bigmemory = new byte[1024 * mb]; 
  } 
 
} 


4.栈溢出

栈溢出也比较常见,有时我们编写的递归调用没有正确的终止条件时,就会使方法不断
递归,栈的深度不断增大,最终发生栈溢出。

package com.cdai.jvm.overflow; 
 
public class * { 
 
  private static int stackdepth = 1; 
   
  public static void *() { 
    stackdepth++; 
    *(); 
  } 
   
  public static void main(string[] args) { 
    try { 
      *(); 
    }  
    catch (exception e) { 
      system.err.println("stack depth: " + stackdepth); 
      e.printstacktrace(); 
    } 
  } 
   
}