【JVM之記憶體與垃圾回收篇】StringTable

StringTable

String的基本特性

  • String：字元串，使用一對 “” 引起來表示
    • String s1 = "Nemo"; // 字面量的定義方式
    • String s2 = new String("Nemo");
  • String 聲明為 final 的，不可被繼承
  • String 實現了 Serializable 介面：表示字元串是支援序列化的。
    實現了 Comparable 介面：表示 string 可以比較大小
  • String 在 jdk8 及以前內部定義了 private final char[] value 用於存儲字元串數據。
    JDK9 時改為 byte[]

為什麼JDK9改變了結構

官方說明：//openjdk.java.net/jeps/254

String 類的當前實現將字元存儲在 char 數組中，每個字元使用兩個位元組（16 位）。從許多不同的應用程式收集的數據表明，字元串是堆使用的主要組成部分，而且，大多數字元串對象只包含拉丁字元。這些字元只需要一個位元組的存儲空間，因此這些字元串對象的內部 char 數組中有一半的空間將不會使用。

我們建議改變字元串的內部表示 class 從 utf – 16 字元數組到位元組數組 + 一個 encoding-flag 欄位。新的 String 類將根據字元串的內容存儲編碼為 ISO-8859-1/Latin-1（每個字元一個位元組）或 UTF-16（每個字元兩個位元組）的字元。編碼標誌將指示使用哪種編碼。

結論：String 再也不用 char[] 來存儲了，改成了 byte[] 加上編碼標記，節約了一些空間

// 之前
private final char value[];
// 之後
private final byte[] value

同時基於 String 的數據結構，例如 StringBuffer 和 StringBuilder 也同樣做了修改

String的不可變性

String：代表不可變的字元序列。簡稱：不可變性。

  • 當對字元串重新賦值時，需要重寫指定記憶體區域賦值，不能使用原有的 value 進行賦值。
  • 當對現有的字元串進行連接操作時，也需要重新指定記憶體區域賦值，不能使用原有的 value 進行賦值。
  • 當調用 String 的 replace() 方法修改指定字元或字元串時，也需要重新指定記憶體區域賦值，不能使用原有的 value 進行賦值。

通過字面量的方式（區別於 new）給一個字元串賦值，此時的字元串值聲明在字元串常量池中。

程式碼

/**
 * String的不可變性
 *
 * @author: Nemo
 */
public class StringTest1 {

    public static void test1() {
        // 字面量定義的方式，「abc」存儲在字元串常量池中
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2);
        s1 = "hello";
        System.out.println(s1 == s2);
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("----------------");
    }

    public static void test2() {
        String s1 = "abc";
        String s2 = "abc";
        // 只要進行了修改，就會重新創建一個對象，這就是不可變性
        s2 += "def";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("----------------");
    }

    public static void test3() {
        String s1 = "abc";
        String s2 = s1.replace('a', 'm');
        System.out.println(s1);
        System.out.println(s2);
    }

    public static void main(String[] args) {
        test1();
        test2();
        test3();
    }
}

運行結果

true
false
hello
abc
----------------
abc
abcdef
----------------
abc
mbc

面試題

/**
 * 面試題
 *
 * @author: Nemo
 */
public class StringExer {
    String str = new String("good");
    char [] ch = {'t','e','s','t'};

    public void change(String str, char ch []) {
        str = "test ok";
        ch[0] = 'b';
    }

    public static void main(String[] args) {
        StringExer ex = new StringExer();
        ex.change(ex.str, ex.ch);
        System.out.println(ex.str);
        System.out.println(ex.ch);
    }
}

輸出結果

good
best

注意

字元串常量池是不會存儲相同內容的字元串的

  • String 的 string Pool 是一個固定大小的 Hashtable，默認值大小長度是 1009。如果放進 string Pool 的 string 非常多，就會造成 Hash 衝突嚴重，從而導致鏈表會很長，而鏈表長了後直接會造成的影響就是當調用 string.intern 時性能會大幅下降。

  • 使用 -XX:StringTablesize 可設置 stringTable 的長度

  • 在 jdk6 中 stringTable 是固定的，就是 1009 的長度，所以如果常量池中的字元串過多就會導致效率下降很快。stringTablesize 設置沒有要求

  • 在 jdk7 中，stringTable 的長度默認值是 60013，stringTablesize 設置沒有要求

  • 在 jdk8 中，StringTable 的長度可以設置的最小值為 1009

String的記憶體分配

在 Java 語言中有 8 種基本數據類型和一種比較特殊的類型 string。這些類型為了使它們在運行過程中速度更快、更節省記憶體，都提供了一種常量池的概念。

常量池就類似一個 Java 系統級別提供的快取。8 種基本數據類型的常量池都是系統協調的，String 類型的常量池比較特殊。它的主要使用方法有兩種。

  • 直接使用雙引號聲明出來的 String 對象會直接存儲在常量池中。
    • 比如：string info=”atguigu.com”;
  • 如果不是用雙引號聲明的 string 對象，可以使用 string 提供的 intern() 方法。

Java 6 及以前，字元串常量池存放在永久代

Java 7 中 oracle 的工程師對字元串池的邏輯做了很大的改變，即將字元串常量池的位置調整到 Java 堆內

  • 所有的字元串都保存在堆（Heap）中，和其他普通對象一樣，這樣可以讓你在進行調優應用時僅需要調整堆大小就可以了。
  • 字元串常量池概念原本使用得比較多，但是這個改動使得我們有足夠的理由讓我們重新考慮在 Java 7 中使用 String.intern()。

Java8 元空間，字元串常量在堆

為什麼StringTable從永久代調整到堆中

官網說明：//www.oracle.com/technetwork/java/javase/jdk7-relnotes-418459.html#jdk7changes

在 JDK 7 中，interned 字元串不再在 Java 堆的永久生成中分配，而是在 Java 堆的主要部分（稱為年輕代和年老代）中分配，與應用程式創建的其他對象一起分配。此更改將導致駐留在主 Java 堆中的數據更多，駐留在永久生成中的數據更少，因此可能需要調整堆大小。由於這一變化，大多數應用程式在堆使用方面只會看到相對較小的差異，但載入許多類或大量使用字元串的較大應用程式會出現這種差異。intern() 方法會看到更顯著的差異。

原因：

  • 永久代的默認比較小
  • 永久代垃圾回收頻率低

String 的基本操作

Java 語言規範里要求完全相同的字元串字面量，應該包含同樣的 Unicode 字元序列（包含同一份碼點序列的常量），並且必須是指向同一個 String 類實例。

字元串拼接操作

  • 常量與常量的拼接結果在常量池，原理是編譯期優化
  • 常量池中不會存在相同內容的變數
  • 只要其中有一個是變數，結果就在堆中。變數拼接的原理是 StringBuilder
  • 如果拼接的結果調用 intern() 方法，則主動將常量池中還沒有的字元串對象放入池中，並返回此對象地址
    public static void test1() {
        String s1 = "a" + "b" + "c";  // 得到 abc的常量池
        String s2 = "abc"; // abc存放在常量池，直接將常量池的地址返回
        /**
         * 最終java編譯成.class，再執行.class
         */
        System.out.println(s1 == s2); // true，因為存放在字元串常量池
        System.out.println(s1.equals(s2)); // true
    }

    public static void test2() {
        String s1 = "javaEE";
        String s2 = "hadoop";
        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";    
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;

        System.out.println(s3 == s4); // true
        System.out.println(s3 == s5); // false
        System.out.println(s3 == s6); // false
        System.out.println(s3 == s7); // false
        System.out.println(s5 == s6); // false
        System.out.println(s5 == s7); // false
        System.out.println(s6 == s7); // false

        String s8 = s6.intern();
        System.out.println(s3 == s8); // true
    }

從上述的結果我們可以知道：

如果拼接符號的前後出現了變數，則相當於在堆空間中 new String()，具體的內容為拼接的結果

而調用 intern 方法，則會判斷字元串常量池中是否存在 JavaEEhadoop 值，如果存在則返回常量池中的值，否者就在常量池中創建

底層原理

拼接操作的底層其實使用了 StringBuilder

s1 + s2 的執行細節

  • StringBuilder s = new StringBuilder();
  • s.append(s1);
  • s.append(s2);
  • s.toString(); -> 類似於new String(“ab”);

在 JDK5 之後，使用的是 StringBuilder，在 JDK5 之前使用的是 StringBuffer

String StringBuffer StringBuilder
String 的值是不可變的，這就導致每次對 String 的操作都會生成新的 String 對象，不僅效率低下，而且浪費大量優先的記憶體空間 StringBuffer 是可變類，和執行緒安全的字元串操作類，任何對它指向的字元串的操作都不會產生新的對象。每個 StringBuffer 對象都有一定的緩衝區容量，當字元串大小沒有超過容量時，不會分配新的容量，當字元串大小超過容量時，會自動增加容量 可變類，速度更快
不可變 可變 可變
執行緒安全 執行緒不安全
多執行緒操作字元串 單執行緒操作字元串

注意，我們左右兩邊如果是變數的話，就是需要 new StringBuilder 進行拼接，但是如果使用的是 final 修飾，則是從常量池中獲取。所以說拼接符號左右兩邊都是字元串常量或常量引用 則仍然使用編譯器優化。也就是說被 final 修飾的變數，將會變成常量，類和方法將不能被繼承。

  • 在開發中，能夠使用 final 的時候，建議使用上
public static void test4() {
    final String s1 = "a";
    final String s2 = "b";
    String s3 = "ab";
    String s4 = s1 + s2;
    System.out.println(s3 == s4);
}

運行結果

true

拼接操作和append性能對比

    public static void method1(int highLevel) {
        String src = "";
        for (int i = 0; i < highLevel; i++) {
            src += "a"; // 每次循環都會創建一個StringBuilder對象
        }
    }

    public static void method2(int highLevel) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < highLevel; i++) {
            sb.append("a");
        }
    }

方法 1 耗費的時間：4005ms，方法 2 消耗時間：7ms

結論：

  • 通過 StringBuilder 的 append() 方式添加字元串的效率，要遠遠高於 String 的字元串拼接方法

好處

  • StringBuilder 的 append 的方式，自始至終只創建一個 StringBuilder 的對象
  • 對於字元串拼接的方式，還需要創建很多 StringBuilder 對象和調用 toString 時候創建的 String 對象
  • 記憶體中由於創建了較多的 StringBuilder 和 String 對象，記憶體佔用過大，如果進行 GC 那麼將會耗費更多的時間

改進的空間

  • 我們使用的是 StringBuilder 的空參構造器，默認的字元串容量是 16，然後將原來的字元串拷貝到新的字元串中，我們也可以默認初始化更大的長度，減少擴容的次數
  • 因此在實際開發中，我們能夠確定，前前後後需要添加的字元串不高於某個限定值，那麼建議使用構造器創建一個閾值的長度

intern()的使用

intern 是一個 native 方法，調用的是底層 C 的方法

字元串池最初是空的，由 String 類私有地維護。在調用 intern 方法時，如果池中已經包含了由 equals(object) 方法確定的與該字元串對象相等的字元串，則返回池中的字元串。否則，該字元串對象將被添加到池中，並返回對該字元串對象的引用。

如果不是用雙引號聲明的 string 對象，可以使用 string 提供的 intern 方法：intern 方法會從字元串常量池中查詢當前字元串是否存在，若不存在就會將當前字元串放入常量池中。
比如：

String myInfo = new string("I love atguigu").intern();

也就是說，如果在任意字元串上調用 string.intern 方法，那麼其返回結果所指向的那個類實例，必須和直接以常量形式出現的字元串實例完全相同。因此，下列表達式的值必定是 true：

（"a"+"b"+"c"）.intern（）=="abc"

通俗點講，Interned string 就是確保字元串在記憶體里只有一份拷貝，這樣可以節約記憶體空間，加快字元串操作任務的執行速度。注意，這個值會被存放在字元串內部池（String Intern Pool）

intern的空間效率測試

我們通過測試一下，使用了 intern 和不使用的時候，其實相差還挺多的

/**
 * 使用Intern() 測試執行效率
 * @author: Nemo
 */
public class StringIntern2 {
    static final int MAX_COUNT = 1000 * 10000;
    static final String[] arr = new String[MAX_COUNT];

    public static void main(String[] args) {
        Integer [] data = new Integer[]{1,2,3,4,5,6,7,8,9,10};
        long start = System.currentTimeMillis();
        for (int i = 0; i < MAX_COUNT; i++) {
            arr[i] = new String(String.valueOf(data[i%data.length])).intern();
        }
        long end = System.currentTimeMillis();
        System.out.println("花費的時間為：" + (end - start));

        try {
            Thread.sleep(1000000);
        } catch (Exception e) {
            e.getStackTrace();
        }
    }
}

結論：對於程式中大量使用存在的字元串時，尤其存在很多已經重複的字元串時，使用 intern() 方法能夠節省記憶體空間。

大的網站平台，需要記憶體中存儲大量的字元串。比如社交網站，很多人都存儲：北京市、海淀區等資訊。這時候如果字元串都調用 intern() 方法，就會很明顯降低記憶體的大小。

面試題

new String(“ab”)會創建幾個對象

/**
 * new String("ab") 會創建幾個對象？ 看位元組碼就知道是2個對象
 *
 * @author: Nemo
 */
public class StringNewTest {
    public static void main(String[] args) {
        String str = new String("ab");
    }
}

我們轉換成位元組碼來查看

 0 new #2 <java/lang/String>
 3 dup
 4 ldc #3 <ab>
 6 invokespecial #4 <java/lang/String.<init>>
 9 astore_1
10 return

這裡面就是兩個對象

  • 一個對象是：new 關鍵字在堆空間中創建
  • 另一個對象：字元串常量池中的對象

new String(“a”) + new String(“b”) 會創建幾個對象

/**
 * new String("ab") 會創建幾個對象？ 看位元組碼就知道是2個對象
 *
 * @author: Nemo
 */
public class StringNewTest {
    public static void main(String[] args) {
        String str = new String("a") + new String("b");
    }
}

位元組碼文件為

 0 new #2 <java/lang/StringBuilder>
 3 dup
 4 invokespecial #3 <java/lang/StringBuilder.<init>>
 7 new #4 <java/lang/String>
10 dup
11 ldc #5 <a>
13 invokespecial #6 <java/lang/String.<init>>
16 invokevirtual #7 <java/lang/StringBuilder.append>
19 new #4 <java/lang/String>
22 dup
23 ldc #8 <b>
25 invokespecial #6 <java/lang/String.<init>>
28 invokevirtual #7 <java/lang/StringBuilder.append>
31 invokevirtual #9 <java/lang/StringBuilder.toString>
34 astore_1
35 return

我們創建了 6 個對象

  • 對象 1：new StringBuilder()
  • 對象 2：new String(“a”)
  • 對象 3：常量池的 a
  • 對象 4：new String(“b”)
  • 對象 5：常量池的 b
  • 對象 6：toString中會約等於創建一個 new String(“ab”)
    • 調用 toString 方法，不會在常量池中生成”ab”（而是會生成”a”和”b”），因為並沒有聲明”ab”常量。當然，如果是 new String(“ab”) 那常量池肯定有常量。

intern 的使用：JDK6 和 JDK7

JDK6 中

String s = new String("1");  // 在常量池中已經有了，"1"常量放到常量池，new對象放到堆
s.intern(); // 將該對象放入到常量池。但是調用此方法沒有太多的區別，因為已經存在了1
String s2 = "1";
System.out.println(s == s2); // false

String s3 = new String("1") + new String("1");//s3變數記錄的地址為：new String("11")
//執行完上一行程式碼以後，字元串常量池中，不存在"11"
s3.intern();//在字元串常量池中生成"11"。如何理解：jdk6中創建了一個新的對象"11"，也就有新的地址
//jdk7：此時常量池中並沒有創建"11"，而是創建了一個指向堆空間中new String("11") 的地址
String s4 = "11";//s4變數記錄的地址：使用的是上一行程式碼執行時，在常量池中生成的"11"地址
System.out.println(s3 == s4); // false

輸出結果

false
false

為什麼對象會不一樣呢？
String s = new String("1");“1” 常量放到常量池，new 對象放到堆
String s2 = "1";時，去檢查常量池，發現有 “1”，直接返回了常量池的引用，沒有創建對象。
對於 s2 字元串來說，它的創建過程同上所說。在創建該對象之前，JVM 會在 String 對象池中去搜索該字元對象是否已經被創建，如果已經被創建，則直接返回一個引用，否則先創建在返回引用。
而 s 字元串變數，它的創建過程就要多一個步驟。除了類似於 str2 字元串對象創建過程以外，它還會額外的創建一個新的 String 對象，也就是 new 關鍵字的作用，並且返回一個引用給 s。

  • 一個是 new 創建的對象，是堆空間中的地址
  • 一個是字面量賦值，是常量池中的對象，是常量池從的地址，顯然不是同一個

如果是下面這樣的，那麼就是 true

String s = new String("1");
s = s.intern();
String s2 = "1";
System.out.println(s == s2); // true

而對於下面的來說，因為 s3 變數記錄的地址是 new String(“11”)，然後這段程式碼執行完以後，常量池中不存在 “11”，這是 JDK6 的關係，然後執行 s3.intern() 後，就會在常量池中生成 “11”，最後 s4 用的就是 s3 的地址

為什麼最後輸出的 s3 == s4 會為false呢？

這是因為在 JDK6 中創建了一個新的對象 “11”，也就是有了新的地址，s2 = 新地址

而在 JDK7 中，在 JDK7 中，並沒有創新一個新對象，而是指向常量池中的新對象

JDK7 中

String s = new String("1");
s.intern();
String s2 = "1";
System.out.println(s == s2); // false

String s3 = new String("1") + new String("1");
s3.intern();
String s4 = "11";
System.out.println(s3 == s4); // true

擴展

String s3 = new String("1") + new String("1");
String s4 = "11";  // 在常量池中生成的字元串
s3.intern();  // 然後s3就會從常量池中找，發現有了，就什麼事情都不做
System.out.println(s3 == s4);

我們將 s4 的位置向上移動一行，發現變化就會很大，最後得到的是 false

總結

總結 string 的 intern() 的使用：

JDK1.6 中，將這個字元串對象嘗試放入串池（字元串常量池）。

  • 如果串池中有，則並不會放入。返回已有的串池中的對象的地址
  • 如果沒有，會把此對象複製一份，放入串池，並返回串池中的對象地址

JDK1.7 起，將這個字元串對象嘗試放入串池。

  • 如果串池中有，則並不會放入。返回已有的串池中的對象的地址
  • 如果沒有，則會把對象的引用地址複製一份，放入串池，並返回串池中的引用地址

練習：

  • 在 JDK6 中，在字元串常量池中創建一個字元串 “ab”
  • 在 JDK8 中，在字元串常量池中沒有創建 “ab”，而是將堆中的地址複製到 串池中。

所以上述結果，在 JDK6 中是：

true
false

在JDK8中是

true
true

針對下面這題，在 JDK6 和 8 中表現的是一樣的

使用 intern() 優化執行效率：空間使用上
結論：對於程式中大量存在的字元串，尤其是其中存在很多重複字元串時，使用 intern() 可以節省記憶體空間。
大的網站平台，需要記憶體中存儲大量的字元串。比如社交網站，很多人都存儲：北京市、海淀區等資訊。這時候如果字元串都調用 intern() 方法，就會明顯降低記憶體的大小。

StringTable的垃圾回收

/**
 * String的垃圾回收
 * -Xms15m -Xmx15m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails
 * @author: Nemo
 */
public class StringGCTest {
    public static void main(String[] args) {
        for (int i = 0; i < 100000; i++) {
            String.valueOf(i).intern();
        }
    }
}

執行之後只有 60000 多個對象，因為進行了垃圾回收。

G1 中的 String 去重操作

官方說明：//openjdk.java.net/jeps/192

注意這裡說的重複，指的是在堆中的數據，而不是常量池中的，因為常量池中的本身就不會重複

String str1 = new String("hello");
String str2 = new String("hello");
是指這個堆中的對象去重

描述

背景：對許多 Java 應用（有大的也有小的）做的測試得出以下結果：

  • 堆存活數據集合裡面 string 對象佔了 25%
  • 堆存活數據集合裡面重複的 string 對象有 13.5%
  • string 對象的平均長度是 45

許多大規模的 Java 應用的瓶頸在於記憶體，測試表明，在這些類型的應用裡面，Java 堆中存活的數據集合差不多 25% 是 String 對象。更進一步，這裡面差不多一半 String 對象是重複的，重複的意思是說：
stringl.equals（string2）= true。堆上存在重複的 string 對象必然是一種記憶體的浪費。這個項目將在 G1 垃圾收集器中實現自動持續對重複的 string 對象進行去重，這樣就能避免浪費記憶體。

實現

  • 當垃圾收集器工作的時候，會訪問堆上存活的對象。對每一個訪問的對象都會檢查是否是候選的要去重的 string 對象。
  • 如果是，把這個對象的一個引用插入到隊列中等待後續的處理。一個去重的執行緒在後台運行，處理這個隊列。處理隊列的一個元素意味著從隊列刪除這個元素，然後嘗試去重它引用的 string 對象。
  • 使用一個 hashtable 來記錄所有的被string 對象使用的不重複的 char 數組。當去重的時候，會查這個 hashtable，來看堆上是否已經存在一個一模一樣的 char 數組。
  • 如果存在，string 對象會被調整引用那個數組，釋放對原來的數組的引用，最終會被垃圾收集器回收掉。
  • 如果查找失敗，char 數組會被插入到 hashtable，這樣以後的時候就可以共享這個數組了。

開啟

命令行選項

  • UseStringDeduplication(bool)：開啟 String 去重，默認是不開啟的，需要手動開啟。
  • PrintStringDeduplicationStatistics(bool)：列印詳細的去重統計資訊
  • StringDeduplicationAgeThreshold(uintx)：達到這個年齡的 String 對象被認為是去重的候選對象
Tags:

VirMach 便宜 VPS

QNews

QNews