終於我用JOL打破了你對java對象的全部想象

時間 2020-06-07

標籤終於 jol 打破 java 對象全部想象欄目 Java 简体版

原文原文鏈接

簡介

使用面向對象的編程語言的好處就是，雖然沒有女友，可是仍然能夠new對象出來。Java是面向對象的編程語言，咱們每天都在使用java來new對象，但估計不多有人知道new出來的對象到底長的什麼樣子，是美是醜到底符不符合咱們的要去？java

對於普通的java程序員來講，可能歷來沒有考慮過java中對象的問題，不懂這些也能夠寫好代碼。git

可是對於一個有鑽研精神的極客來講，確定會想多一些，再多一些，java中的對象究竟是什麼樣的。程序員

今天，小F給你們介紹一款工具JOL，能夠知足你們對java對象的全部想象。github

更多精彩內容且看：編程

更多內容請訪問 www.flydean.com

JOL簡介

JOL的全稱是Java Object Layout。是一個用來分析JVM中Object佈局的小工具。包括Object在內存中的佔用狀況，實例對象的引用狀況等等。數組

JOL能夠在代碼中使用，也能夠獨立的以命令行中運行。命令行的我這裏就不具體介紹了，今天主要講解怎麼在代碼中使用JOL。maven

使用JOL須要添加maven依賴：編程語言

<dependency>
            <groupId>org.openjdk.jol</groupId>
            <artifactId>jol-core</artifactId>
            <version>0.10</version>
</dependency>

添加完依賴，咱們就可使用了。工具

使用JOL分析VM信息

首先咱們看下怎麼使用JOL來分析JVM的信息，代碼很是很是簡單：oop

log.info("{}", VM.current().details());

輸出結果：

# 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]

上面的輸出中，咱們能夠看到：Objects are 8 bytes aligned，這意味着全部的對象分配的字節都是8的整數倍。

使用JOL分析String

上面的都不是重點，重點是怎麼使用JOL來分紅class和Instance信息。

其實java中的對象，除了數組，其餘對象的大小應該都是固定的。咱們先舉一個最最經常使用的字符串來看一下：

log.info("{}",ClassLayout.parseClass(String.class).toPrintable());

上面的例子中，咱們使用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 bytes
Space losses: 0 bytes internal + 2 bytes external = 2 bytes total

先解釋下各個字段的含義，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());

上面的例子，咱們使用了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 bytes
Space losses: 0 bytes internal + 2 bytes external = 2 bytes total

先看結論，和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());

輸出結果：

[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/A
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

類的解析結果，能夠看到Byte數組佔16個字節。

再看實例的狀況：

log.info("{}",ClassLayout.parseInstance("www.flydean.com".getBytes()).toPrintable());

輸出結果：

[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 bytes
Space losses: 0 bytes internal + 1 bytes external = 1 bytes total

能夠看到數組的大小真的變化了，此次變成了32字節。

使用JOL分析自動裝箱

咱們知道，java中的基本類型都有一個和它對於的Object類型，好比long和Long，下面咱們來分析下他們兩個在JVM中的內存區別：

log.info("{}",ClassLayout.parseClass(Long.class).toPrintable());

輸出結果：

[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/A
Instance size: 24 bytes
Space losses: 4 bytes internal + 0 bytes external = 4 bytes total

能夠看到1個Long對象是佔24個字節的，可是其中真正存儲long的value只佔8個字節。

看一個實例：

log.info("{}",ClassLayout.parseInstance(1234567890111112L).toPrintable());

輸出結果：

[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                                1234567890111112
Instance size: 24 bytes
Space losses: 4 bytes internal + 0 bytes external = 4 bytes total

使用JOL分析引用關係

上面咱們使用JOL分析的是class內部的空間使用狀況，那麼若是有外部引用可不能夠分析呢？

HashMap hashMap= new HashMap();
hashMap.put("flydean","www.flydean.com");
log.info("{}", GraphLayout.parseInstance(hashMap).toPrintable());

上面咱們使用一個不一樣的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)

從結果咱們能夠看到HashMap自己是佔用48字節的，它裏面又引用了佔用24字節的key和value。