終於我用JOL打破了你對java對象的所有想象

4{icon} {views}

目錄

  • 簡介
  • JOL簡介
  • 使用JOL分析VM信息
  • 使用JOL分析String
  • 使用JOL分析數組
  • 使用JOL分析自動裝箱
  • 使用JOL分析引用關係
  • 總結

簡介

使用面向對象的編程語言的好處就是,雖然沒有女朋友,但是仍然可以new對象出來。Java是面向對象的編程語言,我們天天都在使用java來new對象,但估計很少有人知道new出來的對象到底長的什麼樣子,是美是丑到底符不符合我們的要去?

對於普通的java程序員來說,可能從來沒有考慮過java中對象的問題,不懂這些也可以寫好代碼。

但是對於一個有鑽研精神的極客來說,肯定會想多一些,再多一些,java中的對象到底是什麼樣的。

今天,小F給大家介紹一款工具JOL,可以滿足大家對java對象的所有想象。

更多精彩內容且看:

  • 區塊鏈從入門到放棄系列教程-涵蓋密碼學,超級賬本,以太坊,Libra,比特幣等持續更新
  • Spring Boot 2.X系列教程:七天從無到有掌握Spring Boot-持續更新
  • Spring 5.X系列教程:滿足你對Spring5的一切想象-持續更新
  • java程序員從小工到專家成神之路(2020版)-持續更新中,附詳細文章教程

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

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>

添加完依賴,我們就可以使用了。

使用JOL分析VM信息

首先我們看下怎麼使用JOL來分析JVM的信息,代碼非常非常簡單:

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。

總結

使用JOL可以分析java類和對象,這個對於我們對JVM和java源代碼的理解和實現都是非常有幫助的。

本文的例子https://github.com/ddean2009/
learn-java-base-9-to-20

本文作者:flydean程序那些事

本文鏈接:http://www.flydean.com/java-object-layout-jol/

本文來源:flydean的博客

歡迎關注我的公眾號:程序那些事,更多精彩等着您!

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

網頁設計公司推薦不同的風格,搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

※回頭車貨運收費標準