JVM对象创建和内存分配

最新推荐文章于 2023-02-13 17:36:02 发布
最新推荐文章于 2023-02-13 17:36:02 发布
阅读量238 收藏 1
点赞数 2
分类专栏： JVM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/a972669015/article/details/116760117
版权

1 对象创建流程

对象创建流程

设置对象头（Object Header）

对象头

初始化零值之后，虚拟机要对对象进行必要的设置，例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码、对象的GC分代年龄等信息。这些信息存放在对象的对象头Object Header之中。

在HotSpot虚拟机中，对象在内存中存储的布局可以分为3块区域：对象头（Header）、 实例数据（Instance Data）和对齐填充（Padding）。

HotSpot虚拟机的对象头包括两部分信息：

1.Mark Word标记字段（32位占4字节，64位占8字节），主要是自身的运行时数据， 如哈希码（HashCode）、GC分代年龄（4bit，所以分代年龄最大不超过15）、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等

2.Klass Pointer类型指针（开启压缩占4字节，关闭压缩占8字节），即对象指向它的类元数据（不同于类class对象，class对象是为开发人员通过反射拿到类信息而提供的；而JVM内部拿这些信息是通过类型指针指向类元数据去获取，类元数据是C++的struct对象来实现的）的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例

3.数组长度（4字节，只有数组对象才有）

2 对象内存分配流程

一个对象创建在什么位置，jvm会有一个比较细节的流程，根据数据的大小，参数的配置，决定如何创建分配，以及其位置，如下图：

对象内存分配流程

1 首先是否满足栈上分配，如果满足对象入栈，不满足进入2；

2 是否满足直接进入老年代（是否为大对象），如果满足对象进入老年代，不满足进入3；

3 尝试在TLAB上分配，如果满足则从eden区为线程划分出一块TLAB内存，并放入对象，不满足进入4；

4 在eden区分配，之后根据gc情况对象会进入s0、s1、老年代。

2.1 对象在栈上分配

如果JAVA中的对象都在堆上进行分配，当对象没有被引用的时候，需要依靠GC进行回收内存，如果对象数量较多的时候，会给GC带来较大压力，也间接影响了应用的性能。

为了减少临时对象在堆内分配的数量，JVM通过逃逸分析确定该对象不会被外部访问。如果不会逃逸可以将该对象在栈上分配内存，这样该对象所占用的内存空间就可以随栈帧出栈而销毁，就减轻了垃圾回收的压力。

对象逃逸分析：就是分析对象动态作用域，是JVM编译器的优化。当一个对象在方法中被定义后，它可能被外部方法所引用，就认为该对象逃逸出去了，即对象的作用域逃逸出方法范围。

public User test1() { 
  User user = new User(); 
  ......
  return user; 
}
public void test2() { 
  User user = new User(); 
  ......
}

test1方法中的user对象被返回了，这个对象的作用域范围不确定

test2方法中的user对象我们可以确定当方法结束这个对象就可以认为是无效对象了，对于这样的对象我们其实可以将其分配在栈内存里，让其在方法结束时跟随栈内存一起被回收掉。

JVM对于这种情况可以通过开启逃逸分析参数-XX:+DoEscapeAnalysis来优化对象内存分配位置，使其通过标量替换优先栈上分配，JDK7之后默认开启逃逸分析，如果要关闭使用参数-XX:-DoEscapeAnalysis。

标量替换：通过逃逸分析确定该对象不会被外部访问，并且对象可以被进一步分解时，JVM不会创建该对象，而是将该对象成员变量分解若干个被这个方法使用的成员变量所代替，这些代替的成员变量在栈帧或寄存器上分配空间，这样就不会因为没有一大块连续空间导致对象内存不够分配。开启标量替换参数-XX:+EliminateAllocations，JDK7之后默认开启，如果要关闭使用参数-XX:-EliminateAllocations。

标量与聚合量：标量即不可被进一步分解的量，而JAVA的基本数据类型就是标量（如：int，long等基本数据类型以及 reference类型等），标量的对立就是可以被进一步分解的量，而这种量称之为聚合量。而在JAVA中对象就是可以被进一 步分解的聚合量。

/** 
  * 栈上分配，标量替换
  * 代码调用了1亿次alloc()，如果是分配到堆上，大概需要1GB以上堆空间，如果堆空间小于该值，必然会触发GC。 
  * 
  * 使用如下参数不会发生GC 
  * ‐Xmx15m ‐Xms15m ‐XX:+DoEscapeAnalysis ‐XX:+PrintGC ‐XX:+EliminateAllocations 
  * 使用如下参数都会发生大量GC 
  * ‐Xmx15m ‐Xms15m ‐XX:‐DoEscapeAnalysis ‐XX:+PrintGC ‐XX:+EliminateAllocations 
  * ‐Xmx15m ‐Xms15m ‐XX:+DoEscapeAnalysis ‐XX:+PrintGC ‐XX:‐EliminateAllocations 
  */ 
  public class AllotOnStack { 
    public static void main(String[] args) { 
      long start = System.currentTimeMillis(); 
      for (int i = 0; i < 100000000; i++) { 
        alloc(); 
      } 
      long end = System.currentTimeMillis(); 
      System.out.println(end ‐ start); 
    } 
    
    private static void alloc() { 
      User user = new User(); 
      user.setId(1); 
    } 
  }

结论：栈上分配依赖于逃逸分析和标量替换，前提是对象不会很大。

2.2 对象进入老年代

1.对象大小

如果是大对象，当新生代eden区无法装入时，会直接进入老年代。

JVM有个参数-XX:PretenureSizeThreshold可以设置当对象大小超过多少后，直接进入老年代。这个参数只在 Serial 和ParNew两个收集器下有效。

可以避免为大对象分配内存时的复制操作而降低效率。

2.对象年龄

一般而言，对象首次创建会被放置在新生代的eden区，如果没有GC介入，则对象不会离开eden区。如果对象的年龄达到一定大小，就会自动离开新生代进入老年代，对象年龄是由对象经历数次GC决定的，在新生代每次GC之后如果对象没有被回收则年龄加1。

虚拟机提供了一个参数-XX:MaxTenuringThreshold来控制新生代对象的最大年龄，根据设置MaxTenuringThreshold参数，可以指定新生代对象经过多少次回收后进入老年代，该参数值默认是15。。

import java.util.HashMap;
import java.util.Map;
​
public class Test05 {
​
  public static void main(String[] args) {
    //初始的对象在eden区
    //参数：-Xmx64M -Xms64M -XX:+PrintGCDetails
    for(int i=0; i< 5; i++){
      byte[] b = new byte[1024*1024];
    }
    
    //测试进入老年代的对象
    //
    //参数：-Xmx1024M -Xms1024M -XX:+UseSerialGC -XX:MaxTenuringThreshold=15 -XX:+PrintGCDetails 
    //-XX:+PrintHeapAtGC
    Map<Integer, byte[]> m = new HashMap<Integer, byte[]>();
    for(int i =0; i <5 ; i++) {
      byte[] b = new byte[1024*1024];
      m.put(i, b);
    }
​
    for(int k = 0; k<20; k++) {
      for(int j = 0; j<300; j++){
        byte[] b = new byte[1024*1024];
      }
    }
  }
}

执行结果：

第一次执行：

Heap PSYoungGen total 18944K, used 6759K [0x00000000feb00000, 0x0000000100000000, 0x0000000100000000) eden space 16384K, 41% used [0x00000000feb00000,0x00000000ff199d70,0x00000000ffb00000) from space 2560K, 0% used [0x00000000ffd80000,0x00000000ffd80000,0x0000000100000000) to space 2560K, 0% used [0x00000000ffb00000,0x00000000ffb00000,0x00000000ffd80000) ParOldGen total 44032K, used 0K [0x00000000fc000000, 0x00000000feb00000, 0x00000000feb00000) object space 44032K, 0% used [0x00000000fc000000,0x00000000fc000000,0x00000000feb00000) Metaspace used 2682K, capacity 4486K, committed 4864K, reserved 1056768K class space used 295K, capacity 386K, committed 512K, reserved 1048576K

 

第二次执行：

[GC (Allocation Failure) [DefNew: 279476K->5668K(314560K), 0.0038935 secs] 279476K->5668K(1013632K), 0.0047935 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] [GC (Allocation Failure) [DefNew: 284561K->5667K(314560K), 0.0041478 secs] 284561K->5667K(1013632K), 0.0041773 secs] [Times: user=0.02 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 284588K->5667K(314560K), 0.0017715 secs] 284588K->5667K(1013632K), 0.0018017 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 284614K->5667K(314560K), 0.0018597 secs] 284614K->5667K(1013632K), 0.0019291 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 284631K->5667K(314560K), 0.0018142 secs] 284631K->5667K(1013632K), 0.0018455 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 284642K->5667K(314560K), 0.0015024 secs] 284642K->5667K(1013632K), 0.0015366 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 284649K->5667K(314560K), 0.0015616 secs] 284649K->5667K(1013632K), 0.0015980 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 284654K->5667K(314560K), 0.0019092 secs] 284654K->5667K(1013632K), 0.0019519 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 284657K->5667K(314560K), 0.0017078 secs] 284657K->5667K(1013632K), 0.0017419 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 284659K->5667K(314560K), 0.0024223 secs] 284659K->5667K(1013632K), 0.0024747 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 284660K->5667K(314560K), 0.0015576 secs] 284660K->5667K(1013632K), 0.0015855 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 284661K->5667K(314560K), 0.0016333 secs] 284661K->5667K(1013632K), 0.0016640 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 284661K->5667K(314560K), 0.0025270 secs] 284661K->5667K(1013632K), 0.0025566 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 284662K->5667K(314560K), 0.0015952 secs] 284662K->5667K(1013632K), 0.0016253 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 284662K->5667K(314560K), 0.0018967 secs] 284662K->5667K(1013632K), 0.0019325 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 284662K->0K(314560K), 0.0045602 secs] 284662K->5667K(1013632K), 0.0045966 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 278995K->0K(314560K), 0.0020099 secs] 284662K->5667K(1013632K), 0.0020417 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 278995K->0K(314560K), 0.0003294 secs] 284662K->5667K(1013632K), 0.0003715 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 278995K->0K(314560K), 0.0002207 secs] 284662K->5667K(1013632K), 0.0002503 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 278995K->0K(314560K), 0.0004489 secs] 284662K->5667K(1013632K), 0.0005001 secs] [Times: user=0.02 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 278995K->0K(314560K), 0.0002128 secs] 284662K->5667K(1013632K), 0.0002389 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [DefNew: 278995K->0K(314560K), 0.0002099 secs] 284662K->5667K(1013632K), 0.0002355 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] Heap def new generation total 314560K, used 33704K [0x00000000c0000000, 0x00000000d5550000, 0x00000000d5550000) eden space 279616K, 12% used [0x00000000c0000000, 0x00000000c20ea030, 0x00000000d1110000) from space 34944K, 0% used [0x00000000d1110000, 0x00000000d1110000, 0x00000000d3330000) to space 34944K, 0% used [0x00000000d3330000, 0x00000000d3330000, 0x00000000d5550000) tenured generation total 699072K, used 5667K [0x00000000d5550000, 0x0000000100000000, 0x0000000100000000) the space 699072K, 0% used [0x00000000d5550000, 0x00000000d5ad8db0, 0x00000000d5ad8e00, 0x0000000100000000) Metaspace used 2683K, capacity 4486K, committed 4864K, reserved 1056768K class space used 295K, capacity 386K, committed 512K, reserved 1048576K

结论：1.大对象直接进入老年代 2.年龄大的对象进入老年代。

2.3 TLAB

Thread Local Allocation Buffer即线程本地分配缓存，是一个线程专用的内存分配区域，即每个线程在Java堆中预先分配一小块内存。JVM使用TLAB来避免多线程内存分配冲突问题，提高了对象分配的效率。TLAB空间一般不会太大，当大对象无法在TLAB上分配时，会直接分配到堆上。

-XX:+UseTLAB 使用TLAB

-XX:+TLABSize 设置TLAB大小

-XX:TLABRefillWasteFraction 设置维护进入TLAB空间的单个对象大小，是一个比例值，默认64，即如果对象大于整个空间的1/64，则在堆创建对象。

-XX:+PrintTLAB 查看TLAB信息

-XX:ResizeTLAB 自调整阈值

public class Test07 {
​
  private static void alloc(){
    byte[] b = new byte[2];
  }
  public static void main(String[] args) {
    
    //TLAB分配
    //参数：-XX:+UseTLAB -XX:+PrintTLAB -XX:+PrintGC -XX:TLABSize=102400 -XX:-ResizeTLAB -XX:TLABRefillWasteFraction=100 -XX:-DoEscapeAnalysis -server
    for(int i=0; i<10000000;i++){
      alloc();
    }   
    
  }
}

2.4 对象动态年龄判断

当前放对象的Survivor区域里(其中一块区域，放对象的那块s区)，一批对象的总大小大于这块Survivor区域内存大小的50%(-XX:TargetSurvivorRatio可以指定)，那么此时大于等于这批对象年龄最大值的对象，就可以直接进入老年代了。这个规则是希望那些可能是长期存活的对象，尽早进入老年代。对象动态年龄判断机制一般是在minor gc之后触发的。

2.5 老年代空间分配担保机制

老年代空间担保机制

2.6 无用的类

方法区主要回收的是无用的类，需要同时满足下面3个条件：

  1. 该类所有的实例都已经被回收，也就是 Java 堆中不存在该类的任何实例。

  2. 加载该类的 ClassLoader 已经被回收。

  3. 该类对应的 java.lang.Class 对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。

性能调优专题(11)之JVM对象创建与内存分配机制深度剖析
jokeMqc的博客
11-14 908
大量的对象被分配在eden区，eden区满了后会触发minor gc，可能会有99%以上的对象成为垃圾被回收掉，剩余存活的对象会被挪到为空的那块survivor区，下一次eden区满了后又会触发minor gc，把eden区和survivor区垃圾对象回收，把剩余存活的对象一次性挪动到另外一块为空的survivor区，因为新生代的对象都是朝生夕死的，存活时间很短，所以JVM默认的8:1:1的比例是很合适的，让eden区尽量的大，survivor区够用即可。而在JAVA中对象就是可以被进一步分解的聚合量。
【JVM】第三篇 JVM对象创建与内存分配机制深度剖析
入坑太深起不来
09-26 1041
大量的对象被分配在Eden区,Eden区满了后会触发Minor GC,可能会有99%以上的对象成为垃圾被回收掉,剩余存活的对象会被挪到S0区,下一次Eden区满了后又会触发Minor GC,把Eden区和survivor区垃圾对象回收,把剩余存活的对象一次性挪动到S1区,因为新生代的对象都是朝生夕死的,存活时间很短,所以JVM默认的8:1:1的比例是很合适的,让Eden区尽量的大,Survivor区够用即可。JVM内存布局规定了Java在运行过程中的内存申请、分配、管理的策略,保证了JVM高效的运行。
JVM的内存分配
weixin_51849480的博客
03-13 2417
JVM的内存分配与GC回收机制JVM内存分配元空间与方法区与永久代堆新生代老年代合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 JVM内存分配 JVM内存分为五部分：元空间（方法区）、堆、虚拟机栈、本地方法栈、程序计数器 元空间与方法区
探索JVM 内存分配
web开发
07-15 169
Java中的堆内存与栈内存： 栈内存主要用于Java 代码的加载和执行，一个典型的例子是递归次数过多，JVM会抛出一个 Runtime错误StackOverflowError，栈内存的分配与管理完全依赖于JVM本身。 内存可以分为大致分为: 永久Generation（Perm Gen）， 长时Generation (Old Ge...
java创建对象时内存的分配_阿里面试官：小伙子，你给我说一下JVM对象创建与内存分配机制吧...
weixin_42683394的博客
02-26 199
内存分配机制逐步分析类加载检查：虚拟机遇到一条new指令(new关键字、对象的克隆、对象的序列化等)时,会先去检查这个指令的参数在常量池中定位到一个类的符号引用，并且这个符号引用代表的类是否应被加载过，如果没有那么就去加载该类分配内存类加载完毕后会给对象分配内存空间。对象的所需的内存大小在类加载完毕后就便可完全确认，为对象分配内存大小的空间等同于把一块确定大小的内存从java堆中划分出来。如何划分...
JVM内存分配
weixin_43774759的博客
04-16 123
内存分区 方法区 方法区主要是用来存储已被虚拟机加载的类的信息、常量、静态变量和即时编译器编译后的代码数据 该区域是被线程共享的 方法区中有一个运行时常量池，用于存放静态编译产生的字面量和符号引用。该常量池具有动态性，就是说常量并不一定是编译时确定的，运行时产生的常量也会在这个常量池中 在该区域内很少发生垃圾回收，在这里的GC主要是对方法区的常量池和对类型的卸载 虚拟机栈 也就是...
JVM对象创建和内存分配原理解析
08-24
1. JVM 对象创建过程：JVM 对象创建过程包括检查参数、类加载、内存分配和对象设置等步骤。 2. 内存分配方式：JVM 使用两种方式进行内存分配：指针碰撞和空闲列表。 3. 并发问题解决方案：JVM 使用 CAS 乐观锁和线程...
Jvm对象内存分配理解
11-24
Jvm 对象内存分配是 Java 虚拟机（JVM）中一个非常重要的过程，它决定了对象的创建、分配和初始化的整个过程。下面将详细探讨 Jvm 对象内存分配的整个过程。 一、对象的创建 Jvm 对象的创建是通过 new 指令来实现...
深入理解java对象，包括对象创建和内存分配
最新发布
01-13
总的来说，理解Java对象的创建、内存分配和JVM的工作机制对于编写高效、健壮的Java代码至关重要。这涉及到堆内存管理、对象生命周期、垃圾收集以及各种JVM优化策略。开发者应时刻关注这些细节，以便在解决性能问题时...
jvm内存分配
sanwishe's bolg
10-21 362
1.对象分配堆上分配 优先在Eden区分配 在JVM新生代堆内存一般由一块Eden区和两块Survivor区组成。在大多数情况下, 对象在新生代Eden区中分配, 当Eden区没有足够空间分配时, JVM会发起一次Minor GC, 将Eden区和其中一块Survivor区内存活的对象放入另一块Survivor区, 如果在Minor GC期间发现新生代存活对象无法放入空闲的Survivor区, 则会
JVM - 内存分配
汤键的博客
02-13 897
JVM - 内存分配
java jvm 内存分配
feng27156的专栏
02-17 1555
1)堆(Heap)和非堆(Non-heap)内存  按照官方的说法：“Java 虚拟机具有一个堆，堆是运行时数据区域，所有类实例和数组的内存均从此处分配。堆是在 Java 虚拟机启动时创建的。”“在JVM中堆之外的内存称为非堆内存(Non-heap memory)”。  可以看出JVM主要管理两种类型的内存：堆和非堆。简单来说堆就是Java代码可及的内存，是留给开发人员使用的；非堆就是
JVM内存分配(JDK8)
paopaodog的博客
10-04 1614
以一个Math类为列，从JVM运行时内存结构，到内存分配流程，最后内存分配参数的含义，串起整个流程。文章还待后续完善。
JVM 内存分配详解
11-03 596
JVM 内存分配详解 2010-12-13 11:25 使用Java程序从数据库中查询大量的数据时出现异常:  java.lang.OutOfMemoryError: Java heap space  在JVM中如果98％的时间是用于GC且可用的 Heap size 不足2％的时候将抛出此异常信息。  JVM堆的设置是指java程序运行过程中JVM可以调配使用的内
JVM内存分配方式
Beau Wang
10-08 593
当Java堆中的内存不是绝对规整的时候，即已使用内存和空闲内存交错混杂，此时无法使用指针碰撞，虚拟机必须维护一个列表，记录哪些内存是可用的，在分配的时候从列表中找到足够大的空间分配给实例对象。当Java堆中的内存是绝对规整的时候，即已使用内存和空闲内存被指针分开，分配内存只需要将这个指针向空闲方向挪与对象大小相等的距离。这种方式需要一个列表，而且存在空间碎片问题。这种方式操作简单、但是要求内存空间规整。具体使用哪种方式分配是由回收机制决定的。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值