对象内存分配

对象栈上分配

我们通过JVM内存分配可以知道JAVA中的对象都是在堆上进行分配，当对象没有被引用的时候，需要依靠GC进行回收内

存，如果对象数量较多的时候，会给GC带来较大压力，也间接影响了应用的性能。为了减少临时对象在堆内分配的数 量，JVM通过 逃逸分析 确定该对象不会被外部访问。如果不会逃逸可以将该对象在 栈上分配 内存，这样该对象所占用的

内存空间就可以随栈帧出栈而销毁，就减轻了垃圾回收的压力。

对象逃逸分析 ：就是分析对象动态作用域，当一个对象在方法中被定义后，它可能被外部方法所引用，例如作为调用参

数传递到其他地方中。

1 public User test1 () {

2 User user = new User ();

3 user . setId ( 1 );

4 user . setName ( "zhuge" );

5 //TODO 保存到数据库

6 return user ;

7 }

8

9 public void test2 () {

10 User user = new User ();

11 user . setId ( 1 );

12 user . setName ( "zhuge" );

13 //TODO 保存到数据库

14 }

很显然test1方法中的user对象被返回了，这个对象的作用域范围不确定，test2方法中的user对象我们可以确定当方法结

束这个对象就可以认为是无效对象了，对于这样的对象我们其实可以将其分配在栈内存里，让其在方法结束时跟随栈内

存一起被回收掉。

JVM对于这种情况可以通过开启逃逸分析参数(-XX:+DoEscapeAnalysis)来优化对象内存分配位置，使其通过 标量替换 优

先分配在栈上( 栈上分配 )，JDK7之后默认开启逃逸分析，如果要关闭使用参数(-XX:-DoEscapeAnalysis)

标量替换： 通过逃逸分析确定该对象不会被外部访问，并且对象可以被进一步分解时， JVM不会创建该对象 ，而是将该

对象成员变量分解若干个被这个方法使用的成员变量所代替，这些代替的成员变量在栈帧或寄存器上分配空间，这样就

不会因为没有一大块连续空间导致对象内存不够分配。开启标量替换参数(-XX:+EliminateAllocations)，JDK7之后默认

开启。

标量与聚合量： 标量即不可被进一步分解的量，而JAVA的基本数据类型就是标量（如：int，long等基本数据类型以及

reference类型等），标量的对立就是可以被进一步分解的量，而这种量称之为聚合量。而在JAVA中对象就是可以被进一

步分解的聚合量。

栈上分配示例：

1 /**

2 * 栈上分配，标量替换

3 * 代码调用了 1 亿次 alloc () ，如果是分配到堆上，大概需要 1 GB 以上堆空间，如果堆空间小于该值，必然会触发 GC 。

4 *

5 * 使用如下参数不会发生 GC

6 * ‐ Xmx15m ‐ Xms15m ‐ XX : + DoEscapeAnalysis ‐ XX : + PrintGC ‐ XX : + EliminateAllocations

7 * 使用如下参数都会发生大量 GC

8 * ‐ Xmx15m ‐ Xms15m ‐ XX : ‐ DoEscapeAnalysis ‐ XX : + PrintGC ‐ XX : + EliminateAllocations

9 * ‐ Xmx15m ‐ Xms15m ‐ XX : + DoEscapeAnalysis ‐ XX : + PrintGC ‐ XX : ‐ EliminateAllocations

10 */

11 public class AllotOnStack {

12

13 public static void main ( String [] args ) {

14 long start = System . currentTimeMillis ();

15 for ( int i = 0 ; i < 100000000 ; i ++ ) {

16 alloc ();

17 }

18 long end = System . currentTimeMillis ();

19 System . out . println ( end ‐ start );

20 }

21

22 private static void alloc () {

23 User user = new User ();

24 user . setId ( 1 );

25 user . setName ( "zhuge" ); 26 }

27 }

结论： 栈上分配依赖于逃逸分析和标量替换

对象在Eden区分配

大多数情况下，对象在新生代中 Eden 区分配。当 Eden 区没有足够空间进行分配时，虚拟机将发起一次Minor GC。我

们来进行实际测试一下。

在测试之前我们先来看看 Minor GC和Full GC 有什么不同呢？

Minor GC/Young GC ：指发生新生代的的垃圾收集动作，Minor GC非常频繁，回收速度一般也比较快。

Major GC/Full GC ：一般会回收老年代 ，年轻代，方法区的垃圾，Major GC的速度一般会比Minor GC的慢

10倍以上。

Eden与Survivor区默认8:1:1

大量的对象被分配在eden区，eden区满了后会触发minor gc，可能会有99%以上的对象成为垃圾被回收掉，剩余存活

的对象会被挪到为空的那块survivor区，下一次eden区满了后又会触发minor gc，把eden区和survivor区垃圾对象回

收，把剩余存活的对象一次性挪动到另外一块为空的survivor区，因为新生代的对象都是朝生夕死的，存活时间很短，所

以JVM默认的8:1:1的比例是很合适的， 让eden区尽量的大，survivor区够用即可，

JVM默认有这个参数-XX:+UseAdaptiveSizePolicy(默认开启)，会导致这个8:1:1比例自动变化，如果不想这个比例有变

化可以设置参数-XX:-UseAdaptiveSizePolicy

示例：

1 // 添加运行 JVM 参数： ‐XX:+PrintGCDetails

2 public class GCTest {

3 public static void main ( String [] args ) throws InterruptedException {

4 byte [] allocation1 , allocation2 /*, allocation3, allocation4, allocation5, allocation6*/ ;

5 allocation1 = new byte [ 60000 * 1024 ];

6

7 //allocation2 = new byte[8000*1024];

8

9 /*allocation3 = new byte[1000*1024];

10 allocation4 = new byte [ 1000 * 1024 ];

11 allocation5 = new byte [ 1000 * 1024 ];

12 allocation6 = new byte [ 1000 * 1024 ]; */

13 }

14 }

15

16 运行结果：

17 Heap

18 PSYoungGen total 76288 K , used 65536 K [ 0x000000076b400000 , 0x0000000770900000 , 0x00000007c0000000 )

19 eden space 65536 K , 100 % used [ 0x000000076b400000 , 0x000000076f400000 , 0x000000076f400000 )

20 from space 10752 K , 0 % used [ 0x000000076fe80000 , 0x000000076fe80000 , 0x0000000770900000 )

21 to space 10752 K , 0 % used [ 0x000000076f400000 , 0x000000076f400000 , 0x000000076fe80000 )

22 ParOldGen total 175104 K , used 0 K [ 0x00000006c1c00000 , 0x00000006cc700000 , 0x000000076b400000 )

23 object space 175104 K , 0 % used [ 0x00000006c1c00000 , 0x00000006c1c00000 , 0x00000006cc700000 )

24 Metaspace used 3342 K , capacity 4496 K , committed 4864 K , reserved 1056768 K

25 class space used 361 K , capacity 388 K , committed 512 K , reserved 1048576 K

我们可以看出eden区内存几乎已经被分配完全（即使程序什么也不做，新生代也会使用至少几M内存）。 假如我们再为

allocation2分配内存会出现什么情况呢？

1 // 添加运行 JVM 参数： ‐XX:+PrintGCDetails

2 public class GCTest {

3 public static void main ( String [] args ) throws InterruptedException {

4 byte [] allocation1 , allocation2 /*, allocation3, allocation4, allocation5, allocation6*/ ;

5 allocation1 = new byte [ 60000 * 1024 ];

6 7 allocation2 = new byte [ 8000 * 1024 ];

8

9 /*allocation3 = new byte[1000*1024];

10 allocation4 = new byte [ 1000 * 1024 ];

11 allocation5 = new byte [ 1000 * 1024 ];

12 allocation6 = new byte [ 1000 * 1024 ]; */

13 }

14 }

15

16 运行结果：

17 [ GC ( Allocation Failure ) [ PSYoungGen : 65253 K ‐> 936 K ( 76288 K )] 65253 K ‐> 60944 K ( 251392 K ), 0.0279083 secs ] [ Times :

user = 0.13 sys = 0.02 , real = 0.03 secs ]

18 Heap

19 PSYoungGen total 76288 K , used 9591 K [ 0x000000076b400000 , 0x0000000774900000 , 0x00000007c0000000 )

20 eden space 65536 K , 13 % used [ 0x000000076b400000 , 0x000000076bc73ef8 , 0x000000076f400000 )

21 from space 10752 K , 8 % used [ 0x000000076f400000 , 0x000000076f4ea020 , 0x000000076fe80000 )

22 to space 10752 K , 0 % used [ 0x0000000773e80000 , 0x0000000773e80000 , 0x0000000774900000 )

23 ParOldGen total 175104 K , used 60008 K [ 0x00000006c1c00000 , 0x00000006cc700000 , 0x000000076b400000 )

24 object space 175104 K , 34 % used [ 0x00000006c1c00000 , 0x00000006c569a010 , 0x00000006cc700000 )

25 Metaspace used 3342 K , capacity 4496 K , committed 4864 K , reserved 1056768 K

26 class space used 361 K , capacity 388 K , committed 512 K , reserved 1048576 K

简单解释一下为什么会出现这种情况： 因为给allocation2分配内存的时候eden区内存几乎已经被分配完了，我们刚刚讲

了当Eden区没有足够空间进行分配时，虚拟机将发起一次Minor GC，GC期间虚拟机又发现allocation1无法存入

Survior空间，所以只好把新生代的对象 提前转移到老年代 中去，老年代上的空间足够存放allocation1，所以不会出现

Full GC。执行Minor GC后，后面分配的对象如果能够存在eden区的话，还是会在eden区分配内存。可以执行如下代码

验证：

1 public class GCTest {

2 public static void main ( String [] args ) throws InterruptedException {

3 byte [] allocation1 , allocation2 , allocation3 , allocation4 , allocation5 , allocation6 ;

4 allocation1 = new byte [ 60000 * 1024 ];

5

6 allocation2 = new byte [ 8000 * 1024 ];

7

8 allocation3 = new byte [ 1000 * 1024 ];

9 allocation4 = new byte [ 1000 * 1024 ];

10 allocation5 = new byte [ 1000 * 1024 ];

11 allocation6 = new byte [ 1000 * 1024 ];

12 }

13 }

14

15 运行结果：

16 [ GC ( Allocation Failure ) [ PSYoungGen : 65253 K ‐> 952 K ( 76288 K )] 65253 K ‐> 60960 K ( 251392 K ), 0.0311467 secs ] [ Times :

user = 0.08 sys = 0.02 , real = 0.03 secs ]

17 Heap

18 PSYoungGen total 76288 K , used 13878 K [ 0x000000076b400000 , 0x0000000774900000 , 0x00000007c0000000 )

19 eden space 65536 K , 19 % used [ 0x000000076b400000 , 0x000000076c09fb68 , 0x000000076f400000 )

20 from space 10752 K , 8 % used [ 0x000000076f400000 , 0x000000076f4ee030 , 0x000000076fe80000 )

21 to space 10752 K , 0 % used [ 0x0000000773e80000 , 0x0000000773e80000 , 0x0000000774900000 )

22 ParOldGen total 175104 K , used 60008 K [ 0x00000006c1c00000 , 0x00000006cc700000 , 0x000000076b400000 )

23 object space 175104 K , 34 % used [ 0x00000006c1c00000 , 0x00000006c569a010 , 0x00000006cc700000 )

24 Metaspace used 3343 K , capacity 4496 K , committed 4864 K , reserved 1056768 K

25 class space used 361 K , capacity 388 K , committed 512 K , reserved 1048576 K

大对象直接进入老年代

大对象就是需要大量连续内存空间的对象（比如：字符串、数组）。JVM参数 -XX:PretenureSizeThreshold 可以设置大

对象的大小，如果对象超过设置大小会直接进入老年代，不会进入年轻代，这个参数只在 Serial 和ParNew两个收集器下

有效。 比如设置JVM参数：-XX:PretenureSizeThreshold=1000000 (单位是字节) -XX:+UseSerialGC ，再执行下上面的第一

个程序会发现大对象直接进了老年代

为什么要这样呢？

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

长期存活的对象将进入老年代

既然虚拟机采用了分代收集的思想来管理内存，那么内存回收时就必须能识别哪些对象应放在新生代，哪些对象应放在

老年代中。为了做到这一点，虚拟机给每个对象一个对象年龄（

Age）计数器。

如果对象在 Eden 出生并经过第一次 Minor GC 后仍然能够存活，并且能被 Survivor 容纳的话，将被移动到 Survivor

空间中，并将对象年龄设为1。对象在 Survivor 中每熬过一次 MinorGC，年龄就增加1岁，当它的年龄增加到一定程度

（默认为15岁，CMS收集器默认6岁，不同的垃圾收集器会略微有点不同），就会被晋升到老年代中。对象晋升到老年代

的年龄阈值，可以通过参数 -XX:MaxTenuringThreshold 来设置。

对象动态年龄判断

当前放对象的Survivor区域里(其中一块区域，放对象的那块s区)，一批对象的总大小大于这块Survivor区域内存大小的

50%(-XX:TargetSurvivorRatio可以指定)，那么此时 大于等于 这批对象年龄最大值的对象，就可以直接进入老年代了，

例如Survivor区域里现在有一批对象，年龄1+年龄2+年龄n的多个年龄对象总和超过了Survivor区域的50%，此时就会

把年龄n(含)以上的对象都放入老年代。这个规则其实是希望那些可能是长期存活的对象，尽早进入老年代。 对象动态年

龄判断机制一般是在minor gc之后触发的。

老年代空间分配担保机制

年轻代每次 minor gc 之前JVM都会计算下老年代 剩余可用空间

如果这个可用空间小于年轻代里现有的所有对象大小之和( 包括垃圾对象 )

就会看一个“

-XX:-HandlePromotionFailure”(jdk1.8默认就设置了)的参数是否设置了

如果有这个参数，就会看看老年代的可用内存大小，是否大于之前每一次minor gc后进入老年代的对象的 平均大小 。

如果上一步结果是小于或者之前说的参数没有设置，那么就会触发一次Full gc，对老年代和年轻代一起回收一次垃圾，

如果回收完还是没有足够空间存放新的对象就会发生"OOM"

当然，如果minor gc之后剩余存活的需要挪动到老年代的对象大小还是大于老年代可用空间，那么也会触发full gc，full

gc完之后如果还是没有空间放minor gc之后的存活对象，则也会发生“OOM”。如下图所示：