简介
使用面向对象的编程语言的好处就是，虽然没有女朋友，但是仍然可以 new 对象出来。Java 是面向对象的编程语言，我们天天都在使用 java 来 new 对象，但估计很少有人知道 new 出来的对象到底长的什么样子，是美是丑到底符不符合我们的要去？
对于普通的 java 程序员来说，可能从来没有考虑过 java 中对象的问题，不懂这些也可以写好代码。
但是对于一个有钻研精神的极客来说，肯定会想多一些，再多一些，java 中的对象到底是什么样的。
今天，小 F 给大家介绍一款工具 JOL，可以满足大家对 java 对象的所有想象。
JOL 简介
JOL 的全称是 Java Object Layout。是一个用来分析 JVM 中 Object 布局的小工具。包括 Object 在内存中的占用情况，实例对象的引用情况等等。
JOL 可以在代码中使用，也可以独立的以命令行中运行。命令行的我这里就不具体介绍了，今天主要讲解怎么在代码中使用 JOL。
使用 JOL 需要添加 maven 依赖：
<dependency> <groupId>org.openjdk.jol</groupId> <artifactId>jol-core</artifactId> <version>0.10</version></dependency>12345
复制代码
添加完依赖，我们就可以使用了。
使用 JOL 分析 VM 信息
首先我们看下怎么使用 JOL 来分析 JVM 的信息，代码非常非常简单：
log.info("{}", VM.current().details());1
复制代码
输出结果：
# Running 64-bit HotSpot VM.# Using compressed oop with 3-bit shift.# Using compressed klass with 3-bit shift.# WARNING | Compressed references base/shifts are guessed by the experiment!# WARNING | Therefore, computed addresses are just guesses, and ARE NOT RELIABLE.# WARNING | Make sure to attach Serviceability Agent to get the reliable addresses.# Objects are 8 bytes aligned.# Field sizes by type: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes]# Array element sizes: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes]123456789
复制代码
上面的输出中，我们可以看到：Objects are 8 bytes aligned，这意味着所有的对象分配的字节都是 8 的整数倍。
使用 JOL 分析 String
上面的都不是重点，重点是怎么使用 JOL 来分成 class 和 Instance 信息。
其实 java 中的对象，除了数组，其他对象的大小应该都是固定的。我们先举一个最最常用的字符串来看一下：
log.info("{}",ClassLayout.parseClass(String.class).toPrintable());1
复制代码
上面的例子中，我们使用 ClassLayout 来解析一个 String 类，先看下输出：
[main] INFO com.flydean.JolUsage - java.lang.String object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 12 (object header) N/A 12 4 byte[] String.value N/A 16 4 int String.hash N/A 20 1 byte String.coder N/A 21 1 boolean String.hashIsZero N/A 22 2 (loss due to the next object alignment)Instance size: 24 bytesSpace losses: 0 bytes internal + 2 bytes external = 2 bytes total12345678910
复制代码
先解释下各个字段的含义，OFFSET 是偏移量，也就是到这个字段位置所占用的 byte 数，SIZE 是后面类型的大小，TYPE 是 Class 中定义的类型，DESCRIPTION 是类型的描述，VALUE 是 TYPE 在内存中的值。
分析下上面的输出，我们可以得出，String 类中占用空间的有 5 部分，第一部分是对象头，占 12 个字节，第二部分是 byte 数组，占用 4 个字节，第三部分是 int 表示的 hash 值，占 4 个字节，第四部分是 byte 表示的 coder，占 1 个字节，最后一个是 boolean 表示的 hashIsZero，占 1 个字节，总共 22 个字节。但是 JVM 中对象内存的分配必须是 8 字节的整数倍，所以要补全 2 字节，最后 String 类的总大小是 24 字节。
有人可能要问小 F 了，如果字符串里面存了很多很多数据，那么对象的大小还是 24 字节吗？
这个问题问得非常有水平，下面我们就来看看怎么使用 JOL 来解析 String 对象的信息：
log.info("{}",ClassLayout.parseInstance("www.flydean.com").toPrintable());1
复制代码
上面的例子，我们使用了 parseInstance 而不是 parseClass 来解析 String 实例的信息。
输出结果：
[main] INFO com.flydean.JolUsage - java.lang.String object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 01 c2 63 a2 (00000001 11000010 01100011 10100010) (-1570520575) 4 4 (object header) 0c 00 00 00 (00001100 00000000 00000000 00000000) (12) 8 4 (object header) 77 1a 06 00 (01110111 00011010 00000110 00000000) (399991) 12 4 byte[] String.value [119, 119, 119, 46, 102, 108, 121, 100, 101, 97, 110, 46, 99, 111, 109] 16 4 int String.hash 0 20 1 byte String.coder 0 21 1 boolean String.hashIsZero false 22 2 (loss due to the next object alignment)Instance size: 24 bytesSpace losses: 0 bytes internal + 2 bytes external = 2 bytes total123456789101112
复制代码
先看结论，和 String Class 一样，这个 String 对象确实只占 24 字节。
实例的解析和 Class 解析的结果差不多，因为是实例对象，所以多了 VALUE 的值。
我们知道在 JDK9 之后，String 的底层存储从 Char[] 变成了 Byte[]用于节约 String 的存储空间。上面的输出中，我们可以看到 String.value 值确实很长，但是保存在 String 中的只是 Byte 数组的引用地址，所以 4 字节就够了。
使用 JOL 分析数组
虽然 String 的大小是不变的，但是其底层数组的大小是可变的。我们再举个例子：
log.info("{}",ClassLayout.parseClass(byte[].class).toPrintable());1
复制代码
输出结果：
[main] INFO com.flydean.JolUsage - [B object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 16 (object header) N/A 16 0 byte [B.<elements> N/AInstance size: 16 bytesSpace losses: 0 bytes internal + 0 bytes external = 0 bytes total123456
复制代码
类的解析结果，可以看到 Byte 数组占 16 个字节。
再看实例的情况：
log.info("{}",ClassLayout.parseInstance("www.flydean.com".getBytes()).toPrintable());1
复制代码
输出结果：
[main] INFO com.flydean.JolUsage - [B 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) 22 13 07 00 (00100010 00010011 00000111 00000000) (463650) 12 4 (object header) 0f 00 00 00 (00001111 00000000 00000000 00000000) (15) 16 15 byte [B.<elements> N/A 31 1 (loss due to the next object alignment)Instance size: 32 bytesSpace losses: 0 bytes internal + 1 bytes external = 1 bytes total12345678910
复制代码
可以看到数组的大小真的变化了，这次变成了 32 字节。
使用 JOL 分析自动装箱
我们知道，java 中的基本类型都有一个和它对于的 Object 类型，比如 long 和 Long，下面我们来分析下他们两个在 JVM 中的内存区别：
log.info("{}",ClassLayout.parseClass(Long.class).toPrintable());1
复制代码
输出结果：
[main] INFO com.flydean.JolUsage - java.lang.Long object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 12 (object header) N/A 12 4 (alignment/padding gap) 16 8 long Long.value N/AInstance size: 24 bytesSpace losses: 4 bytes internal + 0 bytes external = 4 bytes total1234567
复制代码
可以看到 1 个 Long 对象是占 24 个字节的，但是其中真正存储 long 的 value 只占 8 个字节。
看一个实例：
log.info("{}",ClassLayout.parseInstance(1234567890111112L).toPrintable());1
复制代码
输出结果：
[main] INFO com.flydean.JolUsage - java.lang.Long object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 05 00 00 00 (00000101 00000000 00000000 00000000) (5) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 9a 15 00 00 (10011010 00010101 00000000 00000000) (5530) 12 4 (alignment/padding gap) 16 8 long Long.value 1234567890111112Instance size: 24 bytesSpace losses: 4 bytes internal + 0 bytes external = 4 bytes total123456789
复制代码
使用 JOL 分析引用关系
上面我们使用 JOL 分析的是 class 内部的空间使用情况，那么如果有外部引用可不可以分析呢？
HashMap hashMap= new HashMap();hashMap.put("flydean","www.flydean.com");log.info("{}", GraphLayout.parseInstance(hashMap).toPrintable());123
复制代码
上面我们使用一个不同的 layout:GraphLayout,它可以用来分析外部引用情况。
输出结果：
[main] INFO com.flydean.JolUsage - java.util.HashMap@57d5872cd object externals: ADDRESS SIZE TYPE PATH VALUE 7875f9028 48 java.util.HashMap (object) 7875f9058 24 java.lang.String .table[14].key (object) 7875f9070 24 [B .table[14].key.value [102, 108, 121, 100, 101, 97, 110] 7875f9088 24 java.lang.String .table[14].value (object) 7875f90a0 32 [B .table[14].value.value [119, 119, 119, 46, 102, 108, 121, 100, 101, 97, 110, 46, 99, 111, 109] 7875f90c0 80 [Ljava.util.HashMap$Node; .table [null, null, null, null, null, null, null, null, null, null, null, null, null, null, (object), null] 7875f9110 32 java.util.HashMap$Node .table[14] (object)123456789
复制代码
从结果我们可以看到 HashMap 本身是占用 48 字节的，它里面又引用了占用 24 字节的 key 和 value。
总结
使用 JOL 可以分析 java 类和对象，这个对于我们对 JVM 和 java 源代码的理解和实现都是非常有帮助的。
本文的例子https://github.com/ddean2009/learn-java-base-9-to-20
本文作者：flydean 程序那些事
本文链接：http://www.flydean.com/java-object-layout-jol/
本文来源：flydean 的博客
欢迎关注我的公众号:程序那些事，更多精彩等着您！
评论