10|Java对象的内存布局

发布于 2021-10-16  706 次阅读


Java对象的内存布局

在 Java 程序中,我们拥有多种新建对象的方式

  1. new关键字
  2. 反射机制
  3. Object.clone
  4. 反序列化
  5. Unsafe.allocateInstance

其中,Object.clone 方法和反序列化通过直接复制已有的数据,来初始化新建对象的实例字段。

Unsafe.allocateInstance 方法则没有初始化实例字段,而 new 语句和反射机制,则是通过调用构造器来初始化实例字段。

以 new 语句为例,它编译而成的字节码将包含用来请求内存的 new 指令,以及用来调用构造器的 invokespecial 指令。

// Foo foo = new Foo(); 编译而成的字节码
0 new Foo
3 dup
4 invokespecial Foo()
7 astore_1

提到构造器,就不得不提到 Java 对构造器的诸多约束。首先,如果一个类没有定义任何构造器的话, Java 编译器会自动添加一个无参数的构造器。

// Foo类构造器会调用其父类Object的构造器
public Foo();
0 aload_0 [this]
1 invokespecial java.lang.Object() [8]
4 return

然后,子类的构造器需要调用父类的构造器。如果父类存在无参数构造器的话,该调用可以是隐式的,也就是说 Java 编译器会自动添加对父类构造器的调用。

但是,如果父类没有无参数构造器,那么子类的构造器则需要显式地调用父类带参数的构造器。

显式调用又可分为两种:

          一是直接使用“super”关键字调用父类构造器

          二是使用“this”关键字调用同一个类中的其他构造器。

无论是直接的显式调用,还是间接的显式调用,都需要作为构造器的第一条语句,以便优先初始化继承而来的父类字段。(不过这可以通过调用其他生成参数的方法,或者字节码注入来绕开。)

总而言之,当我们调用一个构造器时,它将优先调用父类的构造器,直至 Object 类。这些构造器的调用者皆为同一对象,也就是通过 new 指令新建而来的对象。你应该已经发现了其中的玄机:通过 new 指令新建出来的对象,它的内存其实涵盖了所有父类中的实例字段。也就是说,虽然子类无法访问父类的私有实例字段,或者子类的实例字段隐藏了父类的同名实例字段,但是子类的实例还是会为这些父类实例字段分配内存的。

 

这些字段在内存中的具体分布是怎么样的呢?今天我们就来看看对象的内存布局。

压缩指针

压缩指针所解决的问题

JVM的内存空间有限且昂贵,所以,能缩减的就缩减,通过一定的算法改进压缩类型指针的空间后仍可以寻址到对象的实例对应的类,所以,就采用了压缩指针

关于空间使用的详解可参考本文https://zhuanlan.zhihu.com/p/149678226

在Java虚拟机中,每个Java对象都有一个对象头(object header),包含:

  • 标记字段:用以存储Java虚拟机有关该对象的运行数据,如哈希码,GC信息以及锁信息
  • 类型指针:指向该对象的类
  • 数组长度(只有数组对象有)

为什么要引入基本数据类型的原因(从对象头空间角度分析)

在 64 位的 Java 虚拟机中,对象头的标记字段占 64 位,而类型指针又占了 64 位。也就是说,每一个 Java 对象在内存中的额外开销就是 16 个字节。以 Integer 类为例,它仅有一个 int 类型的私有字段,占 4 个字节。因此,每一个 Integer 对象的额外内存开销至少是 400%。这也是为什么 Java 要引入基本类型的原因之一。

为了尽量较少对象的内存使用量,64 位 Java 虚拟机引入了压缩指针[1]的概念(对应虚拟机选项 -XX:+UseCompressedOops,默认开启),将堆中原本 64 位的 Java 对象指针压缩成 32 位的。这样一来,对象头中的类型指针也会被压缩成 32 位,使得对象头的大小从 16 字节降至 12 字节。当然,压缩指针不仅可以作用于对象头的类型指针,还可以作用于引用类型的字段,以及引用类型数组。

压缩指针的原理

打个比方,路上停着的全是房车,而且每辆房车恰好占据两个停车位。现在,我们按照顺序给它们编号。也就是说,停在 0 号和 1 号停车位上的叫 0 号车,停在 2 号和 3 号停车位上的叫 1 号车,依次类推。原本的内存寻址用的是车位号。比如说我有一个值为 6 的指针,代表第 6 个车位,那么沿着这个指针可以找到 3 号车。现在我们规定指针里存的值是车号,比如 3 指代 3 号车。当需要查找 3 号车时,我便可以将该指针的值乘以 2,再沿着 6 号车位找到 3 号车。这样一来,32 位压缩指针最多可以标记 2 的 32 次方辆车,对应着 2 的 33 次方个车位。当然,房车也有大小之分。大房车占据的车位可能是三个甚至是更多。不过这并不会影响我们的寻址算法:我们只需跳过部分车号,便可以保持原本车号 *2 的寻址系统。

内存对齐是让字段只出现在同一 CPU 的缓存行中。如果字段不是对齐的,那么就有可能出现跨缓存行的字段。也就是说,该字段的读取可能需要替换两个缓存行,而该字段的存储也会同时污染两个缓存行。这两种情况对程序的执行效率而言都是不利的。

 

下面我来介绍一下对象内存布局另一个有趣的特性:字段重排列。

字段重排列

意思是JVM会重新分配字段的位置,和我们Java源码中属性声明的位置存在差异,猜想Java编译器编译后的字节码是没有改变源码中字段声明的位置的,这样做是为了更好的实现内存对齐,内存对齐本质上会浪费一定的内存空间,不过可以减少内存行的读取次数,通过一消一涨的比对发现这样对于JVM的性能有一定的提高,所以,也就使用了这种方式,浪费点空间能提高性能也是值得的

 

思考:

1:为什么一个子类即使无法访问父类的私有实例字段,或者子类实例字段隐藏了父类的同名实例字段,子类的实例还是会为这些父类实例字段分配内存呢?
另外,如果采用指针指向的方式定位父类实例的内容是否能更节省内存空间?

疑问1,子类显然需要为无法访问的父类私有实例字段分配内存,可以想到的一种情况是,子类可以调用父类的非私有方法,而父类的非私有方法显然有可能使用到子类无法访问的父类私有实例字段。

她喜欢所以就做咯