个人中心
gpt4 book ai didi

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

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 25 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章了解Java虚拟机JVM的基本结构及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方法，将新的字符串常量放入池中.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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动态代理 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
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对象， 这样就可以通过反复创建代理类达到使方法区溢出的目的.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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.堆溢出 。

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

?
1
2
3
4
5
6
7
8
9
10
11
12
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.栈溢出 。

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.cdai.jvm.overflow;
 
public class StackOverflow {
 
   private static int stackDepth = 1 ;
   
   public static void stackOverflow() {
     stackDepth++;
     stackOverflow();
   }
   
   public static void main(String[] args) {
     try {
       stackOverflow();
     } 
     catch (Exception e) {
       System.err.println( "Stack depth: " + stackDepth);
       e.printStackTrace();
     }
   }
   
}

  。

最后此篇关于了解Java虚拟机JVM的基本结构及JVM的内存溢出方式的文章就讲到这里了,如果你想了解更多关于了解Java虚拟机JVM的基本结构及JVM的内存溢出方式的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

25 4 0
文章推荐： Vert-x-通过异步的方式使用JDBC连接SQL
文章推荐： Java实现爬虫给App提供数据（Jsoup 网络爬虫）
文章推荐： 深入学习Java编程中的字符串的进阶使用
文章推荐： Java基于Socket实现HTTP下载客户端
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com