包裝類型緩存問題分析

文章目錄

3.Long 的緩存問題分析

寫在前面

最近的生活十分單調，基本上是早上一杯咖啡寫寫代碼，下午睡一覺去健身房健個身，晚上再摸摸魚（看視頻、打遊戲、看課外書），一天就過去了。幾星期下來，可達鴨眉頭一皺，發現事情並不簡單

這樣下去沒成長呀！日復一日地寫之前的東西，面向CV編程，整日的CURD，業務還是那類業務，技術棧還是老一套，除了提高IDEA快捷鍵的熟悉程度以及減少機械鍵盤的壽命，實在想不到還有什麼進步了。噢！這不行。

哇，那麼我也學學人家吧。把開發推一推，早上學基礎知識。其他時間再做開發。嗯，就這麼說定了。因此也就有了這第一篇搬運文章——不知不覺攢下了很多專欄、圖文課以及專業書籍都沒來得及看，現在開始一天一篇吧(^▽)

該文章搬運自：解鎖大廠思維：剖析《阿里巴巴Java開發手冊》，鏈接地址：https://www.imooc.com/read/55。

其中前半部分是直接摘抄作者專欄，後半部分是個人總結+實踐。在此寫成文章權當學習筆記及知識分享。勤奮的搬運工一枚！

我要扼住命運的咽喉，它妄想使我屈服，這絕對辦不到。生活是這樣美好，活他一千輩子吧！——貝多芬

1. 前言

《手冊》第 7 頁有一段關於包裝對象之間值的比較問題的規約 1：

【強制】所有整型包裝類對象之間值的比較，全部使用 equals 方法比較。
說明：對於 Integer var = ? 在 - 128 至 127 範圍內的賦值，Integer 對象是在 IntegerCache.cache 產生，會複用已有對象，這個區間內的 Integer 值可以直接使用 == 進行判斷，但是這個區間之外的所有數據，都會在堆上產生，並不會複用已有對象，這是一個大坑，推薦使用 equals 方法進行判斷。

這條建議非常值得大家關注，而且該問題在 Java 面試中十分常見。

我們還需要思考以下幾個問題：

如果不看《手冊》，我們如何知道 Integer var = ? 會緩存 -128 到 127 之間的賦值？
爲什麼會緩存這個範圍的賦值？
我們如何學習和分析類似的問題？

2. Integer緩存問題分析

我們先看下面的示例代碼，並思考該段代碼的輸出結果：

public class IntTest {
	public static void main(String[] args) {
	    Integer a = 100, b = 100, c = 150, d = 150;
	    System.out.println(a == b);
	    System.out.println(c == d);
	}
}

通過運行代碼可以得到答案，程序輸出的結果分別爲： true , false。

那麼爲什麼答案是這樣？

結合《手冊》的描述很多人可能會頗有自信地回答：因爲緩存了 -128 到 127 之間的數值，就沒有然後了。

那麼爲什麼會緩存這一段區間的數值？緩存的區間可以修改嗎？其它的包裝類型有沒有類似緩存？

what? 咋還有這麼多問題？這誰知道啊！

莫急，且看下面的分析。

2.1 源碼分析

首先我們可以通過源碼對該問題進行分析。

我們知道，Integer var = ? 形式聲明變量，會通過 java.lang.Integer#valueOf(int) 來構造 Integer 對象。

我們先看該函數源碼：

/**
 * Returns an {@code Integer} instance representing the specified
 * {@code int} value.  If a new {@code Integer} instance is not
 * required, this method should generally be used in preference to
 * the constructor {@link #Integer(int)}, as this method is likely
 * to yield significantly better space and time performance by
 * caching frequently requested values.
 *
 * This method will always cache values in the range -128 to 127,
 * inclusive, and may cache other values outside of this range.
 *
 * @param  i an {@code int} value.
 * @return an {@code Integer} instance representing {@code i}.
 * @since  1.5
 */
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

通過源碼可以看出，如果用 Ineger.valueOf(int) 來創建整數對象，參數大於等於整數緩存的最小值（ IntegerCache.low ）並小於等於整數緩存的最大值（ IntegerCache.high）, 會直接從緩存數組 (java.lang.Integer.IntegerCache#cache) 中提取整數對象；否則會 new 一個整數對象。

那麼這裏的緩存最大和最小值分別是多少呢？

從上述註釋中我們可以看出，最小值是 -128, 最大值是 127。

那麼爲什麼會緩存這一段區間的整數對象呢？

通過註釋我們可以得知：如果不要求必須新建一個整型對象，緩存最常用的值（提前構造緩存範圍內的整型對象），會更省空間，速度也更快。

這給我們一個非常重要的啓發：

如果想減少內存佔用，提高程序運行的效率，可以將常用的對象提前緩存起來，需要時直接從緩存中提取。

那麼我們再思考下一個問題： Integer 緩存的區間可以修改嗎？

通過上述源碼和註釋我們還無法回答這個問題，接下來，我們繼續看java.lang.Integer.IntegerCache 的源碼：

/**
 * Cache to support the object identity semantics of autoboxing for values between
 * -128 and 127 (inclusive) as required by JLS.
 *
 * The cache is initialized on first usage.  The size of the cache
 * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
 * During VM initialization, java.lang.Integer.IntegerCache.high property
 * may be set and saved in the private system properties in the
 * sun.misc.VM class.
 */

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];
    static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
           // 省略其它代碼
    }
      // 省略其它代碼
}

因此可以通過修改這兩個參數其中之一，讓緩存的最大值大於等於 150。

如果作出這種修改，示例的輸出結果便會是： true,true。

學到這裏是不是發現，對此問題的理解和最初的想法有些不同呢？

這段註釋也解答了爲什麼要緩存這個範圍的數據：

是爲了自動裝箱時可以複用這些對象 ，這也是 JLS2 的要求。

我們可以參考 JLS 的 Boxing Conversion 部分的相關描述。

If the valuepbeing boxed is an integer literal of type intbetween -128and 127inclusive (§3.10.1), or the boolean literal trueorfalse(§3.10.3), or a character literal between '\u0000'and '\u007f'inclusive (§3.10.4), then let aand bbe the results of any two boxing conversions of p. It is always the case that a==b.

在 -128 到 127 （含）之間的 int 類型的值，或者 boolean 類型的 true 或 false，以及範圍在’\u0000’和’\u007f’ （含）之間的 char 類型的數值 p，自動包裝成 a 和 b 兩個對象時，可以使用 a == b 判斷 a 和 b 的值是否相等。

2.2 反彙編法

那麼究竟 Integer var = ? 形式聲明變量，是不是通過 java.lang.Integer#valueOf(int) 來構造 Integer 對象呢？總不能都是猜測 N 個可能的函數，然後斷點調試吧？

如果遇到其它類似的問題，沒人告訴我底層調用了哪個方法，該怎麼辦？ 囧…

這類問題有個殺手鐗，可以通過對編譯後的 class 文件進行反彙編來查看。

首先編譯源代碼：javac IntTest.java

然後需要對代碼進行反彙編，執行：javap -c IntTest

如果想了解 javap 的用法，直接輸入 javap -help 查看用法提示（很多命令行工具都支持 -help 或 --help 給出用法提示）。

反編譯後，我們得到以下代碼：

Compiled from "IntTest.java"
public class com.chujianyun.common.int_test.IntTest {
  public com.chujianyun.common.int_test.IntTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: bipush        100
       2: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
       5: astore_1
       6: bipush        100
       8: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      11: astore_2
      12: sipush        150
      15: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      18: astore_3
      19: sipush        150
      22: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      25: astore        4
      27: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
      30: aload_1
      31: aload_2
      32: if_acmpne     39
      35: iconst_1
      36: goto          40
      39: iconst_0
      40: invokevirtual #4                  // Method java/io/PrintStream.println:(Z)V
      43: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
      46: aload_3
      47: aload         4
      49: if_acmpne     56
      52: iconst_1
      53: goto          57
      56: iconst_0
      57: invokevirtual #4                  // Method java/io/PrintStream.println:(Z)V
      60: return
}

可以明確得 “看到” 這四個 ``Integer var = ? 形式聲明的變量的確是通過 java.lang.Integer#valueOf(int) 來構造 Integer` 對象的。

至於對彙編後的代碼詳細分析請參閱網上資料。這裏小白就先略過了。

3.Long 的緩存問題分析

我們學習的目的之一就是要學會舉一反三。因此我們對 Long 也進行類似的研究，探究兩者之間有何異同。

3.1 源碼分析

類似的，我們接下來分析 java.lang.Long#valueOf(long) 的源碼：

/**
 * Returns a {@code Long} instance representing the specified
 * {@code long} value.
 * If a new {@code Long} instance is not required, this method
 * should generally be used in preference to the constructor
 * {@link #Long(long)}, as this method is likely to yield
 * significantly better space and time performance by caching
 * frequently requested values.
 *
 * Note that unlike the {@linkplain Integer#valueOf(int)
 * corresponding method} in the {@code Integer} class, this method
 * is <em>not</em> required to cache values within a particular
 * range.
 *
 * @param  l a long value.
 * @return a {@code Long} instance representing {@code l}.
 * @since  1.5
 */
public static Long valueOf(long l) {
    final int offset = 128;
    if (l >= -128 && l <= 127) { // will cache
        return LongCache.cache[(int)l + offset];
    }
    return new Long(l);
}

發現該函數的寫法和 Ineger.valueOf(int) 非常相似。

我們同樣也看到， Long 也用到了緩存。使用 java.lang.Long#valueOf(long) 構造 Long 對象時，值在 [-128, 127] 之間的 Long 對象直接從緩存對象數組中提取。

而且註釋同樣也提到了：緩存的目的是爲了提高性能。

但是通過註釋我們發現這麼一段提示：

Note that unlike the {@linkplain Integer#valueOf(int) corresponding method} in the {@code Integer} class, this method is not required to cache values within a particular range.

注意：和 Ineger.valueOf(int) 不同的是，此方法並沒有被要求緩存特定範圍的值。

這也正是上面源碼中緩存範圍判斷的註釋爲何用 // will cache 的原因（可以對比一下上面 Integer 的緩存的註釋）。

因此我們可知，雖然此處採用了緩存，但應該不是 JLS 的要求。

那麼 Long 類型的緩存是如何構造的呢？

我們查看緩存數組的構造：

private static class LongCache {
    private LongCache(){}

    static final Long cache[] = new Long[-(-128) + 127 + 1];

    static {
        for(int i = 0; i < cache.length; i++)
            cache[i] = new Long(i - 128);
    }
}

可以看到，它是在靜態代碼塊中填充緩存數組的。

3.2 反編譯

同樣地我們也編寫一個示例片段：

public class LongTest {

    public static void main(String[] args) {
        Long a = -128L, b = -128L, c = 150L, d = 150L;
        System.out.println(a == b);
        System.out.println(c == d);
    }
}

編譯源代碼： javac LongTest.java

對編譯後的類文件進行反彙編: javap -c LongTest

得到下面反編譯的代碼：

public class com.imooc.basic.learn_int.LongTest {
  public com.imooc.basic.learn_int.LongTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: ldc2_w        #2                  // long -128l
       3: invokestatic  #4                  // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
       6: astore_1
       7: ldc2_w        #2                  // long -128l
      10: invokestatic  #4                  // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
      13: astore_2
      14: ldc2_w        #5                  // long 150l
      17: invokestatic  #4                  // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
      20: astore_3
      21: ldc2_w        #5                  // long 150l
      24: invokestatic  #4                  // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
      27: astore        4
      29: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
      32: aload_1
      33: aload_2
      34: if_acmpne     41
      37: iconst_1
      38: goto          42
      41: iconst_0
      42: invokevirtual #8                  // Method java/io/PrintStream.println:(Z)V
      45: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
      48: aload_3
      49: aload         4
      51: if_acmpne     58
      54: iconst_1
      55: goto          59
      58: iconst_0
      59: invokevirtual #8                  // Method java/io/PrintStream.println:(Z)V
      62: return
}

我們從上述代碼中發現 Long var = ? 的確是通過 java.lang.Long#valueOf(long) 來構造對象的。

4. 總結

本文通過源碼分析法、閱讀 JLS 和 JVMS、使用反彙編法，對 Integer 和 Long 緩存的目的和實現方式問題進行了深入分析。

讓大家能夠通過更豐富的手段來學習知識和分析問題，通過對緩存目的的思考來學到更通用和本質的東西。

本文使用的幾種手段將是我們未來常用的方法，也是工作進階的必備技能和一個程序員專業程度的體現，希望大家未來能夠多動手實踐。

5. 個人感悟

整數緩存的範圍是JLS 的要求，也體現了提高性能的常見思想：空間換時間。參考 java.lang.Integer.IntegerCache 的註釋。 Java開發涉及自動拆箱和裝箱，而比較常用的數字範圍是 -128 到 127。如果這段整數自動裝箱不復用已經緩存的對象，會造成沒必要的資源消耗，但是自動裝箱所有整數範圍的對象又沒有必要。另外體現了對象池設計模式。
要養成直接去 JDK對應源碼看註釋的習慣，養成看Java語言規範和JVM規範的習慣。網上百度到的質量參差不齊，甚至可能是錯誤的。
Byte，Short，Long、Integer的緩存有固定範圍: -128 到 127，對於 Character緩存範圍是 0 到 127。除了 Integer 可以通過參數改變範圍外，其它的都不行。

6. 個人實踐

通過上述學習我們知道了——

裝箱都是執行valueOf方法：如果有緩存將判定是否在緩存範圍內，否則new。
拆箱則是執行xxxValue方法！<floatValue、longValue、intValue。。。>

6.1 Boolean的緩存問題分析

對於Boolean類型：提供靜態的2種枚舉值，通過這種方式實現緩存？…

    /**
     * The {@code Boolean} object corresponding to the primitive
     * value {@code true}.
     */
    public static final Boolean TRUE = new Boolean(true);

    /**
     * The {@code Boolean} object corresponding to the primitive
     * value {@code false}.
     */
    public static final Boolean FALSE = new Boolean(false);

Boolean類型的valueOf方法

public static Boolean valueOf(boolean b) {
    return (b ? TRUE : FALSE);
}

同時還有另外一個方法重載的valueOf方法

public static Boolean valueOf(String s) {
    return parseBoolean(s) ? TRUE : FALSE;
}

parseBoolean(String s)方法源碼如下，能夠將String類型的true、false字符串轉換爲boolean類型。

public static boolean parseBoolean(String s) {
    return ((s != null) && s.equalsIgnoreCase("true"));
}

6.2 Character的緩存問題分析

CharacterCache 緩存 Character

private static class CharacterCache {
    private CharacterCache(){}

    static final Character cache[] = new Character[127 + 1];

    static {
        for (int i = 0; i < cache.length; i++)
            cache[i] = new Character((char)i);
    }
}

6.3 測試

public static void main(String[] args) {
    Long a = 3L;
    Integer b = 4;
    Character c = 5;
    Byte d = 7;
    Short e = 1;
    System.out.println(a == Long.valueOf(a));
    System.out.println(b == Integer.valueOf(b));
    System.out.println(c == Character.valueOf(c));
    System.out.println(d == Byte.valueOf(d));
    System.out.println(e == Short.valueOf(e));
}

運行的結果都爲true！

在斷點單測時發現：都跳入了valueOf方法！

包裝類型緩存問題分析

文章目錄

寫在前面

1. 前言

2. Integer緩存問題分析

2.1 源碼分析

2.2 反彙編法

3.Long 的緩存問題分析

3.1 源碼分析

3.2 反編譯

4. 總結

5. 個人感悟

6. 個人實踐

6.1 Boolean的緩存問題分析

6.2 Character的緩存問題分析

6.3 測試

初學者必備——win10搭建Java後臺開發環境大集合

快速上手之SpringBoot+Mybatis實現簡單登錄功能

開啓編程世界的臨門一腳

2020年，大學生該如何成爲一名初級碼農

魔改lenosp腳手架

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結