对象的创建过程

对象创建的主要流程:

jvm_memory_fenpei

1、类加载检查

虚拟机遇到一条new指令时,首先检查这个指令的参数是否能在常量池中定位到一个类的符号引用,并且检查这个符号引用代表的类是否已被加载、解析和初始化过,如果没有,那必须先执行响应的类加载过程。

2、分配内存

在类加载检查通过后,接下来虚拟机将为新生对象分配内存。对象所需的大小在类加载完成后便可以完全确认。
为对象分配空间的任务等同于把一块确定大小的内存从Java堆中划分出来。

分配方式有 “指针碰撞” 和 “空闲列表” 两种,选择那种分配方式由 Java 堆是否规整决定,而Java堆是否规整又由所采用的垃圾收集器是否带有压缩整理功能决定。

划分内存的方法
  • "指针碰撞" (Bump the Pointer)(默认用指针碰撞)
    • 如果Java堆中内存规整,没有碎片的情况下,所有用过的内存都放在一起,空闲的内存放在另一边,中间放着一个指针作为分界点的指示器,那所分配内存就仅仅是把那个指针挪动一段与对象大小相等的距离。
    • GC收集器:Serial、ParNew
    • 如下图所示,为对象分配内存,会获取上一次分配的内存位置索引,继续往后分配,这里可以简单理解为类似ArrayList的add方法。

java_vm_memory_qukuai

  • "空闲列表"(Free List)

    • 如果Java堆中的内存并不是规整的,已使用的内存和空闲的内存相互交错,那就没有办法简单的进行指针碰撞了,虚拟机就必须维护一个列表,记录上哪块内存是可用的,在分配的时候从列表中找到一块足够大的空间划分给对象实例。并更新列表上的记录。
    • GC垃圾收集器:CMS
内存分配并发问题

在创建对象的时候有一个很重要的问题,就是线程安全。

假设"指针碰撞" 分配法来分配,倘若A线程、B线程,都需要分配1M内存,A线程获取到最后一次分配内存的索引位置,假设这个索引是10M的位置,那么从堆里面的这个索引10M位置向右移动1M的内存空间,就是A线程的内存空间,如果在A线程分配后还没及时更新堆内存的索引位置,而这时候B线程获取到索引,它所获取到的还是10M的那个位置,所以最后两个线程所分配空间就冲突了。

通常来讲,虚拟机采用两种方式来保证线程安全:

  • CAS+失败重试:
    • CAS是乐观锁的一种实现方式。所谓乐观锁就是,每次不加锁而是假设没有冲突的去完成某项操作,如果因为冲突失败就重试,知道成功为止。
    • 虚拟机采用CAS + 失败重试的方式保证更新操作的原子性。
  • TLAB
    • 为每一个线程预先在Eden区分配一块内存,JVM在给线程中的对象分配内存时,先在TLAB分配,当对象大于TLAB的剩余内存或TLAB的内存已用尽时,再采用上述的CAS进行内存分配。
    • 通过-XX:+UseTLAB参数来设定虚拟机是否使用TLAB(JVM会默认开启­XX:+UseTLAB),­XX:TLABSize 指定TLAB大小。

3、初始化

内存分配完成后,虚拟机需要将分配的内存空间都初始化为零值(不包括对象头),如果使用TLAB,这一工作过程也可以提前至TLAB分配时进行。这一步操作保证了对象的实例字段在Java代码中可以不赋初始值就可以直接使用,程序能访问到这些字段的数据类型所对应的零值。

4、设置对象头

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

  • 在HostSpot虚拟机中,对象在内存中存储的布局可以分为3块区域
    • 对象头(Header)
      • 一部分用户存储对象自身的运行时数据,如哈希码、GC分代年龄、锁状态标志、线程持有的锁、偏向锁ID、偏向时间戳等等。
      • 一部分是存放的类型指针,即对象指向它的类元数据的指针,虚拟机通过这个指针来确定这个对象是哪个类的实例。
      • 数组长度(只有在对象是数组类型的情况下才会有,存放的就是数组的长度,length)
    • 实例数据(Instance Data)
      • 这个很好理解,就是程序中所定义的各种类型的字段内容。
    • 对其填充数据(Padding)
      • 出于计算机组成原理考虑,对象的大小为8字节的整数倍的情况下,性能更优,所以Hotspot规定对象的大小必须是8字节的整数倍,倘若不足,则用对其填充数据补位。

5、执行 init方法

执行init方法,即对象按照程序员意愿进行初始化。
如下列代码,在第三步初始化时该age变量会初始化为零值,那么在执行init方法,就会将age赋值为1.

    private int age = 1;

除了赋值之外,还会执行该类的构造方法。

对象的大小与指针压缩

查看对象大小

添加maven依赖

<!-- https://mvnrepository.com/artifact/org.openjdk.jol/jol-core -->
<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.10</version>
</dependency>

代码示例

public class JolTest {
    public static void main(String[] args) {
        ClassLayout layout = ClassLayout.parseInstance(new Object());
        System.out.println(layout.toPrintable());
        System.out.println();


        layout = ClassLayout.parseInstance(new int[]{});
        System.out.println(layout.toPrintable());
        System.out.println();

        layout = ClassLayout.parseInstance(new User());
        System.out.println(layout.toPrintable());
        System.out.println();
    }
}

运行结果(Java默认开启压缩所有指针)

## object 对象 16字节,三个header,一个补位,各占4个字节。

java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

## 数组对象 16字节,可以看到它有4个header,最后一个header是数组长度,它的补位是0,因为4个header已经是8的整数倍。
[I object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           6d 01 00 f8 (01101101 00000001 00000000 11111000) (-134217363)
     12     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
     16     0    int [I.<elements>                             N/A
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

## user对象 24字节,三个header,两个变量,一个补位 各占4字节。
cn.pencilso.study.studyjvm.User object internals:
 OFFSET  SIZE               TYPE DESCRIPTION                               VALUE
      0     4                    (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4                    (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4                    (object header)                           51 f2 00 f8 (01010001 11110010 00000000 11111000) (-134155695)
     12     4                int User.age                                  0
     16     4   java.lang.String User.name                                 null
     20     4                    (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

关闭所有指针再次运行

## 关闭指针压缩,将参数添加到VM options
## UseCompressedOops 压缩所有指针
## UseCompressedClassPointers 压缩对象头里的指针类型 Klass Pointer
-XX:-UseCompressedOops -XX:-UseCompressedClassPointers

执行结果如下

## object 对象,对象头变成了4个,因为Klass Pointer没压缩,4字节放不下,所以又加了一个header存放Klass Pointer
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           00 7c 2c 09 (00000000 01111100 00101100 00001001) (153910272)
     12     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

## header 也增加了一个,和object同理
[I object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           68 6b 2c 09 (01101000 01101011 00101100 00001001) (153906024)
     12     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
     16     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
     20     4        (alignment/padding gap)                  
     24     0    int [I.<elements>                             N/A
Instance size: 24 bytes
Space losses: 4 bytes internal + 0 bytes external = 4 bytes total


## header也增加了一个,和object同理,并且name字段也变成了8字节。
cn.pencilso.study.studyjvm.User object internals:
 OFFSET  SIZE               TYPE DESCRIPTION                               VALUE
      0     4                    (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4                    (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4                    (object header)                           58 dc 8f 09 (01011000 11011100 10001111 00001001) (160423000)
     12     4                    (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
     16     4                int User.age                                  0
     20     4                    (alignment/padding gap)                  
     24     8   java.lang.String User.name                                 null
Instance size: 32 bytes
Space losses: 4 bytes internal + 0 bytes external = 4 bytes total
为什么要进行指针压缩?
  • 在64位平台的Hotspot中使用32位指针,内存会多出1.5倍左右,使用较大指针在主内存和缓存之间移动数据,占用较大宽带,同时GC也会承受较大压力。
  • 为了减少64位平台下内存的消耗,启用指针压缩功能
  • 在jvm中,32位地址最大支持4G内存(2的32次方),可以通过对对象指针的压缩编码、解码方式进行优化,使得jvm只用32位地址就可以支持更大的内存配置(小于等于32G)
  • 堆内存小于4G时,不需要启用指针压缩,JVM会直接去除高32位地址,即使用低虚拟地址空间
  • 堆内存大于32G时,压缩指针会失效,会强制使用64位(即8字节)来对Java对象寻址,所以堆内存不要大于32G为好

对象内存分配

对象栈上分配

一般来讲Java中的对象都是分配在堆上面的,在一些情况下会分配到线程栈上面。

JVM通过逃逸分析确定对象只会存在方法里面,而不会return等方式被外部所访问,也就是当对象逃不出方法的时候,就可以将对象分配到栈内存上面,这样的话,当该方法执行结束,方法对应的栈帧会释放,而栈帧里分配的对象也会释放,从而不需要GC主动回收垃圾。

JVM通过开启逃逸分析参数(-XX:+DoescapeAnalysis)来优化对象内存位置,使其通过标量替换优先分配在栈上,JDK1.7以后默认会开启逃逸分析。

  • 标量替换
    • 一般来说给对象分配内存是需要一块连续的空间,而栈帧的内存一般来说比较小,而且可用内存空间可能不连续,会导致无法分配对象内存,而标量替换就是解决这个问题,要分配到栈上的对象,并不会真的创建对象,而是将该对象的所有成员变量,分配到栈帧里的各个内存区域。
    • 开启标量替换参数(-XX:+EliminateAllocations) ,JDK1.7以后默认开启。
  • 标量和聚合量
    • 标量即不可被进一步分解的量,而JAVA的基本数据类型就是标量(如:int,long等基本数据类型以及 reference类型等),标量的对立就是可以被进一步分解的量,而这种量称之为聚合量。而在JAVA中对象就是可以被进一 步分解的聚合量。
逃逸分析示例
  • 未逃逸
    public void alloc() {
        User user = new User();
        user.setAge(20);
        user.setName("大白");
    }
  • 逃逸
    public User alloc() {
        User user = new User();
        user.setAge(20);
        user.setName("大白");
        return user;
    }

对象在Eden区分配

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

  • Minor GC/Young GC:指发生新生代的的垃圾收集动作,Minor GC非常频繁,回收速度一般也比较快。
  • Major GC/Full GC:一般会回收老年代 ,年轻代,方法区的垃圾,Major GC的速度一般会比Minor GC的慢 10倍以上。
Eden & Survivor

Eden与Survivor区默认8:1:1

大量的对象被分配在Eden区,Eden满了后会触发Minor Gc,可能会有大量的对象成为垃圾被回收掉,剩余存活的对象会被挪到为空的那块Survivor区,下一次Eden区满了后又会触发Minor Gc,把Eden区和Survivor区垃圾对象回收,把剩余存活的对象一次性挪动到另外一块为空的Survivor区,因为新生代的对象都是朝生夕死的,存活时间很短,所以JVM默认的8:1:!的比例是很合适的。

理应让Eden区尽量的大,Survivor区够用即可。

JVM默认有这个参数-XX:+UseAdaptiveSizePolicy(默认开启),会导致这个8:1:1比例自动变化(JVM会自动调整大小),如果不想这个比例有变 化可以设置参数-XX:-UseAdaptiveSizePolicy

代码示例:

// 添加运行JVM参数: -XX:+PrintGCDetails

    public static void main(String[] args) {
        int oneMb = 1024 * 1024;
        byte[] allocation1;
        //申请一百兆的内存
        allocation1 = new byte[oneMb * 100];
    }
//-------------运行结果,可以看到eden区使用率达到了85%,而Survivor区的from、to两块区域都是空的
Heap
 PSYoungGen      total 153088K, used 112927K [0x0000000715580000, 0x0000000720000000, 0x00000007c0000000)
  eden space 131584K, 85% used [0x0000000715580000,0x000000071c3c7ca8,0x000000071d600000)
  from space 21504K, 0% used [0x000000071eb00000,0x000000071eb00000,0x0000000720000000)
  to   space 21504K, 0% used [0x000000071d600000,0x000000071d600000,0x000000071eb00000)
 ParOldGen       total 349696K, used 0K [0x00000005c0000000, 0x00000005d5580000, 0x0000000715580000)
  object space 349696K, 0% used [0x00000005c0000000,0x00000005c0000000,0x00000005d5580000)
 Metaspace       used 3093K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 339K, capacity 388K, committed 512K, reserved 1048576K

再次分配内存,撑满Eden区,查看效果


    public static void main(String[] args) {
        int oneMb = 1024 * 1024;
        byte[] allocation1,allocation2;
        //申请100兆的内存
        allocation1 = new byte[oneMb * 100];
        //申请30M的内存
        allocation2 = new byte[oneMb * 30];
    }
//-------------运行结果,可以看到eden区使用率降到了24%,而from使用率升到了3%,而且老年代使用率也提升到了29%。
//之前提到过,Eden区满了会触发GC,在给allocation2申请30M内存时,发现Eden区不够用了,那么就会触发一次Minor GC。
//GC期间发现allocation1太大了,Survivor区放不下,所以会把新生代的对象(allocation1)提前转移到老年代中去,老年代上的空间足够存放allocation1,所以不会触发Full GC。
//form区的3%,是JVM自己的一些对象,即使程序什么都不做,也会有一些对象存在,一开始是分配在Eden区,当触发MinorGc时会挪动到Survivor区。
//而allocation1是一个数组,它是连续的内存,所以allocation1整个都被移动到了老年代,form剩下的就是JVM自己的一些内存对象。
//执行Minor GC后,后面分配的对象如果能够存在Eden区的话,还是会在Eden区分配内存。
Heap
 PSYoungGen      total 153088K, used 32772K [0x0000000715580000, 0x0000000728080000, 0x00000007c0000000)
  eden space 131584K, 24% used [0x0000000715580000,0x00000007174c90e0,0x000000071d600000)
  from space 21504K, 3% used [0x000000071d600000,0x000000071d6b8020,0x000000071eb00000)
  to   space 21504K, 0% used [0x0000000726b80000,0x0000000726b80000,0x0000000728080000)
 ParOldGen       total 349696K, used 102408K [0x00000005c0000000, 0x00000005d5580000, 0x0000000715580000)
  object space 349696K, 29% used [0x00000005c0000000,0x00000005c6402010,0x00000005d5580000)
 Metaspace       used 3093K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 339K, capacity 388K, committed 512K, reserved 1048576K

大对象直接进入老年代

大对象就是需要大量连续内存空间的对象(字符串、数组)。
JVM参数 -XX:PretenureSizeThreshold 可以设置大对象的大小,如果对象超过设置大小会直接进入老年代,不会进入年轻代,这个参数只在Serial和ParNew两个收集器下有小。

比如设置JVM参数:-XX:PretenureSizeThreshold=1000000(单位是字节) -XX:+UseSerialGC,再执行上面的第一个程序会发现大对象直接进了老年代。

这么设计的主要目的是为了避免大对象分配内存时的复制操作而降低效率。

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

既然虚拟机采用了分代收集的思想来管理内存,那么内存回收时就必须能识别哪些对象应放在新生代,哪些对象应放在老年代中,为了做到这一点,虚拟机给每个对象一个对象年龄(age)计数器。

如果对象在Eden出生并经过第一次Minor GC后仍然能够存活,并且能被Survivor容纳的话,将被移动到Survivor空间中,并且对象年龄设置为1,对象在Survivor中每经历一次Minor GC,年龄会增加1岁,当它的年龄增加到一定程度(默认为15岁,CMS收集器默认6岁,最高15岁),就会被晋升到老年代中。对象晋升到老年代的年龄阈值,可以通过参数-XX:MaxTenuringThreshold来设置。

对象动态年龄判断

当前对象的Survivor区域里(Survivor两块区域中的非空区域),一批对象的总大小大于这块Survivor区域内存大小的50%(-XX:TargetSurvivorRatio可以指定),那么此时大于等于这批对象年龄的对象,就可以进入老年代了。

举个例子,年龄为1的对象占用%33,年龄为2的对象占用%33,它们总和为66%,所以会把年龄大于等于2的对象全部挪动到老年代。

这个规则其实是希望那些可能是长期存活的对象,尽早进入老年代。对象动态年 龄判断机制一般是在minor gc之后触发的。

老年代空间分配担保机制

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

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

就会看一个"-XX:HandlePromotionFailure"(jdk1.8默认设置)的参数是否设置了

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

如果上一步结果是小于护着没有设置参数,那么久会触发一次Full Gc,对老年代和年轻代一起回收一次垃圾,如果回收完还是没有足够控件存放新的对象就会发生"OOM"

当然,如果Minor Gc之后剩余存活的需要挪动到老年代的对象大小还是大雨老年代可用空间,那么也会触发Full gc,Full gc完之后如果还是没有空间放Minor GC之后的存活对象,还是会触发"OOM"

流程图大概如下:
jvm_memory_gczhixing

对象内存回收

堆中几乎放着所有的对象实例,对垃圾对象回收前的第一步就是要判断哪些对象已经死亡(即不能再被任何途径使用的对象)。

引用计数法

给对象中添加一个引用计数器,每当有一个地方引用它,计数器就加1,当引用失效,计数器就减1;

任何时候计数器为0的对象就是不可能再被引用的。
这个方法实现简单,效率高,但是目前主流的虚拟机中并没有选择这个算法来管理内存,其最重要的原因是它很难解决对象之间的相互循环引用的问题。
如下列代码:

public class ReferenceCountingGc {
   ReferenceCountingGc object;

   public static void main(String[] args) {
       ReferenceCountingGc gc1 = new ReferenceCountingGc();//引用计数器+1,对象被gc1引用
       ReferenceCountingGc gc2 = new ReferenceCountingGc();//引用计数器+1,对象被gc2引用
       //---- 这时候 gc1、gc2 两个对象各自的引用计数器都为1
       
       gc1.object = gc2;//引用计数器+1
       gc2.object = gc1;//引用计数器+1

       gc1 = null;//引用计数器-1
       gc2 = null;//引用计数器-1
   }
}

上述代码,最终gc1、gc2的引用计数器为1,因为它们互相引用了,并且计数器不为0就无法通知gc回收它们。

可达性分析算法

Gc Roots根节点:线程栈的本地变量、静态变量、本地方法栈的变量等等。

可达性分析算法的思路就是通过一系列的“GC Roots”,也就是根对象作为起始节点集合,从根节点开始,根据引用关系向下搜索,搜索过程所走过的路径称为引用链,如果某个对象到GC Roots间没有任何引用链相连,就表明该对象是垃圾对象,可以进行回收。

常见引用类型

  • 强引用
public static User user = new User();
  • 软引用
    • 将对象用SoftReference软引用类型的对象包裹,正常情况不会被回收,但是GC做完后发现释放不出空间存放新的对象,则会把这些软引用的对象回收掉。
    • 软引用可用来实现内存敏感的高速缓存。
 public static SoftReference<User> user = new SoftReference<User>(new User());
  • 弱引用
    • 将对象用WeakReference弱引用类型的对象包裹,跟软引用差不多,GC会直接回收掉,很少用。
public static WeakReference<User> user = new WeakReference<User>(new User());
  • 虚引用
    • 虚引用顾名思义,就是形同虚设。与其他几种引用都不同,虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。

finalize()方法最终判定对象是否存活

即使在可达性分析算法中不可达的对象,也并非是必须回收的,要真正宣告一个对象死亡,至少要经理再次标记过程。

标记的前提是对象在进行可达性分析后发现没有与GC Roots相连接的引用链。

  • 第一次标记并进行一次筛选
    • 筛选的条件是此对象是否有必要执行finalize方法
    • 当对象没有覆盖finalize方法,对象将直接被回收
  • 第二次标记
    • 如果这个对象覆盖了finalize方法,finalize方法是对象脱逃死亡命运的最后一次机会,如果对象要在finalize中成功拯救自己,只要重新与GC Roots 引用链上的任何一个对象建立关联即可,比如把自己赋值给某个类变量或对象的成员变量,那在第二次标记时它将移除出"即将回收"的集合。
    • 如果对象这时候还没有逃脱,那基本上它就真的要被回收了
    • 一个对象的finalize方法只会被执行一次。也就是说通过finalize的方法只能救自己一次。

如何判断一个类是无用的类

方法区主要回收的是无用的类,那么当类同时满足以下三个条件才能算是无用的类:

  • 该类的所有实例都被回收,也就是Java堆中不存在该类的任何实例对象。
  • 加载该类的CLassLoader已经被回收(除非是自定义的加载器,不然的话,类加载器不会被回收的)
  • 该类对应的java.lang.Class对象没有在任何地方被引用,无法在任何地方通过反射访问该类的方法。