java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java对象在内存中的布局

Java对象在内存中的布局是如何实现的?

作者:yamikaze

Java对象在内存中属于oop-klass二分模型,即对象的实例数据和对象类型的元数据(字段定义、方法、常量池等元数据)是分开存储的.而由于JVM对对象内相同宽度的字段分配在一起,所以只要指定了字段类型分配的顺序,就可以计算出每种类型字段相对于当前对象的偏移起始位置

1、-XX:FieldsAllocationStyle

对象在内存中的布局首要相关配置就是FieldsAllocationStyle,这个配置有3个可选值,即0、1、2。当值为2的时候,会经过一些逻辑判断最终转化为0或者1.

当然,上面这2种分配策略只是针对大部分正常情况而言,有以下几种情况是会有所区别的(只是有部分区别,大致是没有问题的)

其他:

由于在计算对象字段的布局(字段基于对象起始位置的偏移量)时,当前类上述各种类型变量的个数是已知的,所以每种类型的起始偏移量就可以通过计算得到,如下:

next_nonstatic_word_offset  = next_nonstatic_double_offset +
                                (nonstatic_double_count * BytesPerLong);
next_nonstatic_short_offset = next_nonstatic_word_offset +
  (nonstatic_word_count * BytesPerInt);
next_nonstatic_byte_offset  = next_nonstatic_short_offset +
  (nonstatic_short_count * BytesPerShort);
next_nonstatic_padded_offset = next_nonstatic_byte_offset +
  nonstatic_byte_count;

而对于oops对象的偏移量处理会比较特殊,如果-XX:FieldsAllocationStyle=0, 那么oops的偏移量起始位置就为对象头之后,如果-XX:FieldsAllocationStyle=1, 则会进行下列处理,使得next_nonstatic_padded_offset与heapOopSize是对齐的。如下:

// let oops jump before padding with this allocation style
if( allocation_style == 1 ) {
  next_nonstatic_oop_offset = next_nonstatic_padded_offset;
  if( nonstatic_oop_count > 0 ) {
    next_nonstatic_oop_offset = align_size_up(next_nonstatic_oop_offset, heapOopSize);
  }
  next_nonstatic_padded_offset = next_nonstatic_oop_offset + (nonstatic_oop_count * heapOopSize);
}

同时由于这个oops补齐操作以及计算完所有字段的偏移量之后,会再进行补齐操作,与heapOopSize进行对齐,heapOopSize在开启和关闭压缩指针的情况下,值分表为4和8。

2、-XX:CompactFields

-XX:CompactFields表示是否将对象中较窄的数据插入到间隙中,-XX:+CompactFields表示插入,-XX:-CompactFields则是不插入。默认JVM是开启插入的。

那么这儿就要讨论一下为什么会插入,以及怎么插入?

首先需要了解Java对象的大致内存布局,最开始的一块区域存放对象标记以及元数据指针,然后才是实例数据,如下图所示:

在这里插入图片描述

它们分别对应普通对象与数组对象在内存中的布局。由于对象字段布局是在Class文件解析的时候计算的,而数组类没有对应的Class文件,所以数组对象的布局这儿不做讨论。

继续回到刚刚的话题,将对象中较窄数据的插入间隙,可以细分为2种情况

最终可以得到如下图所示:

在这里插入图片描述

间隙插入受-XX:CompactFields影响外,还受到配置-XX:-UseCompressedOops的影响,回到上面的对齐,在开启压缩指针的情况下,元数据指针占8个字节,这时候按照上面的细分情况1,也就不存在对齐了,而细分的情况二,由于父类在计算完字段偏移量之后会与heapOopSize对齐,heapOopSize在开启压缩指针的情况下为jintSize, 关闭的情况下为oopSize,分别对应4和8, 也就是关闭压缩指针的情况下,无论如何都不会发生间隙插入。

3、@sun.misc.Contended

@sun.misc.Contended也会影响对象在内存中的布局,这个注解是为了解决伪共享(False Sharing)的问题,关于伪共享的问题这儿就不讲解了。

@sun.misc.Contended 可以用于修饰类、也可以用于修饰字段。

对于在类上的修饰来讲,会在2个地方增加ContendedPaddingWidth,这个变量值为128。

一个地方是对象标记和元数据指针 + 父类实例数据(当前可能没有父类实例数据)之后 + ContendedPaddingWidth,然后再与8位进行对齐,另一个地方是,所有的非Contended实例字段偏移量计算完毕后,再加上ContendedPaddingWidth。

处理完类,接下来是字段,这儿的字段偏移量计算跟上面不一样,并没有按照double/long、ints、chars/shorts、bytes/booleans的顺序来,而是按照@sun.misc.Contended对应的group来进行计算,相同group的字段会放在一起,不同group的字段之间会以ContendedPaddingWidth来隔开,这儿比较特殊的情况是默认分组,默认分组为0,这个分组对应的每个字段在计算完偏移量之后都会加上ContendedPaddingWidth。所以@sun.misc.Contended修饰的字段布局如下图所示:

在这里插入图片描述

同时在计算每个字段偏移前,会使当前的偏移量与当前字段类型所对应的字节数对齐,例如int,当前偏移量会以4字节进行对齐,对齐之后的偏移量为当前int字段的偏移量。

4、静态字段的偏移量计算

静态字段的偏移量计算不受-XX:FieldsAllocationStyle和-XX:CompactFields的影响,会直接按照

oops、double/long、ints、chars/shorts、bytes/booleans的顺序进行偏移量的计算。

同时给静态字段 加上@sun.misc.Contended不会起到任何作用。

5、示例

5.1、-XX:FieldsAllocationStyle

测试代码:

final class NoChild {
    private Boolean value = Boolean.TRUE;
    private byte b;
    private int i;
}

@Test
public void test() {
  declaredFields = NoChildContended.class.getDeclaredFields();
  for (Field field : declaredFields) {
    if (Modifier.isStatic(field.getModifiers())) {
      long offset = unsafe.staticFieldOffset(field);
      System.out.println(field.getDeclaringClass().getName() + " static field " + field.getName() + 					" offset is " + offset);
    } else {
      long offset = unsafe.objectFieldOffset(field);
      System.out.println(field.getDeclaringClass().getName() + " field " + field.getName() + " 						offset is " + offset);
    }
  }
}

运行结果:

-XX:FieldsAllocationStyle=0 -XX:-UseCompressedOops
//可以看到对象实例数据顺序为value、int、byte,这儿由于没有开启指针压缩,所以对象引用占了8个字节。
org.yamikaze.NoChild field value offset is 16
org.yamikaze.NoChild field b offset is 28
org.yamikaze.NoChild field i offset is 24
-XX:FieldsAllocationStyle=1 -XX:-UseCompressedOops
//可以看到先分配 int变量 i,其次byte变量 b,最后才是对象 value
//这儿的byte变量b偏移是20,占用大小1字节,而经过对齐之后,会产生3个字节的align
org.yamikaze.NoChild field value offset is 24
org.yamikaze.NoChild field b offset is 20
org.yamikaze.NoChild field i offset is 16

5.2、-XX:CompactFields

测试代码:

class Parent {
    private long value;
    private int j;
    private byte b;
}

class Child2 extends Parent {
    private byte d;
    private long a;
    private int f;
}

@Test
public void test() {
  
  Child2 c = new Child2();
  Unsafe unsafe = UnSafeUtils.getUnsafe();
  Field[] declaredFields = c.getClass().getSuperclass().getDeclaredFields();
  for (Field field : declaredFields) {

    if (Modifier.isStatic(field.getModifiers())) {
      long offset = unsafe.staticFieldOffset(field);
      System.out.println(field.getDeclaringClass().getName() + " static field " + field.getName() + 				" offset is " + offset);
    } else {
      long offset = unsafe.objectFieldOffset(field);
      System.out.println(field.getDeclaringClass().getName() + " field " + field.getName() + " 						offset is " + offset);
    }
  }

  declaredFields = c.getClass().getDeclaredFields();
  for (Field field : declaredFields) {
    if (Modifier.isStatic(field.getModifiers())) {
      long offset = unsafe.staticFieldOffset(field);
      System.out.println(field.getDeclaringClass().getName() + " static field " + field.getName() + 				" offset is " + offset);

    } else {
      long offset = unsafe.objectFieldOffset(field);
      System.out.println(field.getDeclaringClass().getName() + " field " + field.getName() + " 					offset is " + offset);
    }
  }
}

测试结果:

-XX:+CompactFields -XX:+UseCompressedOops
//可以看到子类Child2的变量f并没有按照double/long、ints、shorts/chars、bytes/booleans的顺序计算偏移量,
//而是插入到了间隙里面
org.yamikaze.Parent field value offset is 16
org.yamikaze.Parent field j offset is 12
org.yamikaze.Parent field b offset is 24
org.yamikaze.Child2 field d offset is 40
org.yamikaze.Child2 field a offset is 32
org.yamikaze.Child2 field f offset is 28
-XX:-CompactFields -XX:+UseCompressedOops
//由于关闭了CompactFields,所以变量f的按照上面的顺序进行偏移量计算
org.yamikaze.Parent field value offset is 16
org.yamikaze.Parent field j offset is 24
org.yamikaze.Parent field b offset is 28
org.yamikaze.Child2 field d offset is 44
org.yamikaze.Child2 field a offset is 32
org.yamikaze.Child2 field f offset is 40

5.3、Contended

测试代码:

@Contended
final class NoChildContended {

    private byte b;

    @Contended("aaa")
    private double value;

    @Contended("bbb")
    private int value1;
}

@Test
public void test() {
  declaredFields = NoChildContended.class.getDeclaredFields();
  for (Field field : declaredFields) {

    if (Modifier.isStatic(field.getModifiers())) {
      long offset = unsafe.staticFieldOffset(field);
      System.out.println(field.getDeclaringClass().getName() + " static field " + field.getName() + " offset is " + offset);

    } else {
      long offset = unsafe.objectFieldOffset(field);
      System.out.println(field.getDeclaringClass().getName() + " field " + field.getName() + " offset is " + offset);
    }
  }
}

测试结果:

-XX:-RestrictContended
同分组时:
org.yamikaze.NoChildContended field b offset is 140
org.yamikaze.NoChildContended field value offset is 272
org.yamikaze.NoChildContended field value1 offset is 280
不同分组(默认分组):
org.yamikaze.NoChildContended field b offset is 140
org.yamikaze.NoChildContended field value offset is 272
org.yamikaze.NoChildContended field value1 offset is 408

可以看到,由于Class上有@sun.misc.Contended注解修饰,导致byte变量的偏移量很大(12 + 128) 同样byte变量之后的value,偏移量再次增加了128,达到272(141 + 128 = 269然后与4字节对齐得到272),然后相同分组的value1紧跟着value,而在不同分组的情况下,value1和value之间又隔了128。

6、其他

6.1、通过Unsafe获取实例字段和静态字段的偏移量

//实例字段
unsafe.objectFieldOffset(field);
//静态字段
unsafe.staticFieldOffset(field);

6.2、Unsafe是如何进行实例字段和静态字段偏移量的获取,以及如何通过CAS操作改变值

回到上文的偏移量计算,在经过计算后,每个字段相对于对象头的偏移量都是已知的,这个偏移量会保存到字段信息里面去,那么获取字段偏移量也很简单,直接拿到字段相关信息取得offset即可,而通过CAS操作改变字段的值也很简单,当前对象指针加上字段偏移量就是当前字段在内存中的地址,直接通过指针更字段值即可。

到此这篇关于Java对象在内存中的布局是如何实现的?的文章就介绍到这了,更多相关Java对象在内存中的布局内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

您可能感兴趣的文章:
阅读全文