本文將介紹 HotSpot 中的 String Pool，字串常量池，相對是一篇比較簡單的文章，大家花幾分鐘就看完了，
在 Java 世界中，構造一個 Java 物件是一個相對比較重的活，而且還需要垃圾回收，而快取池就是為了緩解這個問題的，
我們來看下基礎型別的包裝類的快取，Integer 默認快取 -128 ~ 127 區間的值，Long 和 Short 也是快取了這個區間的值，Byte 只能表示 -127 ~ 128 范圍的值，全部快取了，Character 快取了 0 ~ 127 的值，Float 和 Double 沒有快取的意義，
Integer 可通過設定 java.lang.Integer.IntegerCache.high 擴大快取區間
String 不是基礎型別，但是它也有同樣的機制，通過 String Pool 來快取 String 物件，假設 “Java” 這個字串我們會在應用程式中使用多次，我們肯定不希望在每次使用到的時候，都重新在堆中創建一個新的物件，
當然，之所以 Integer、Long、String 這些類的物件可以快取，是因為它們是不可變類
基礎型別包裝類的快取池使用一個陣列進行快取，而 String 型別，JVM 內部使用 HashTable 進行快取，我們知道，HashTable 的結構是一個陣列，陣列中每個元素是一個鏈表，和我們平時使用的 HashTable 不同，JVM 內部的這個 HashTable 是不可以動態擴容的，
[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-RhF2TcAR-1602205521962)(https://assets.javadoop.com/imgs/20510079/string/1.png)]
創建和回收
當我們在程式中使用雙引號來表示一個字串時，這個字串就會進入到 String Pool 中，當然，這里說的是已被加載到 JVM 中的類，
這是一個不夠嚴謹的說法，請參見評論區的討論，
另外，就是 String#intern() 方法，這個方法的作用就是：
- 如果字串未在 Pool 中，那么就往 Pool 中增加一條記錄，然后回傳 Pool 中的參考，
- 如果已經在 Pool 中，直接回傳 Pool 中的參考，
只要 String Pool 中的 String 物件對于 GC Roots 來說不可達，那么它們就是可以被回收的，
如果 Pool 中物件過多，可能導致 YGC 變長，因為 YGC 的時候，需要掃描 String Pool，可以看看笨神大佬的文章《JVM原始碼分析之String.intern()導致的YGC不斷變長》，
討論 String Pool 的實作
1、首先，我們先考慮 String Pool 的空間問題，
在 Java 6 中，String Pool 置于 PermGen Space 中，PermGen 有一個問題，那就是它是一個固定大小的區域，雖然我們可以通過 -XX:MaxPermSize=N 來設定永久代的空間大小，但是不管我們設定成多少，它終歸是固定的，
所以，在 Java 6 中，我們應該盡量小心使用 String.intern() 方法，否則容易導致 OutOfMemoryError，
到了 Java 7，大佬們已經著手去掉 PermGen Space 了，首先，就是將 String Pool 移到了堆中，
把 String Pool 放到堆中，即使堆的大小也是固定的，但是這個時候，對于應用調優作業，只需要調整堆大小就行了，
到了 Java 8，PermGen 已經被徹底廢棄，出現了堆外記憶體區域 MetaSpace，String Pool 相應的從堆轉移到了 MetaSpace 中，
在 Java 8 中，String Pool 依然還是在 Heap Space 中，感謝評論區的讀者指出錯誤，大家可以看一下我后面寫的關于 MetaSpace 的文章，那篇文章深入分析了 MetaSpace 的構成，
2、其次，我們再討論 String Pool 的實作問題，
前面我們說了 String Pool 使用一個 HashTable 來實作，這個 HashTable 不可以擴容，也就意味著極有可能出現單個 bucket 中的鏈表很長，導致性能降低，
在 Java 6 中，這個 HashTable 固定的 bucket 數量是 1009，后來添加了選項（-XX:StringTableSize=N）可以配置這個值，到 Java 7（7u40），大佬們提高了這個默認值到 60013，Java 8 依然也是使用這個值，對于絕大部分應用來說，這個值是足夠用的，當然，如果你會在代碼中大量使用 String#intern()，那么有必要手動設定一下這個值，
為什么是 1009，而不是 1000 或者 1024？因為 1009 是質數，有利于達到更好的散列，60013 同理，
JVM 內部的 HashTable 是不擴容的，但是不代表它不 rehash，它會在發現散列不均勻的時候進行 rehash，這里不展開介紹，
3、觀察 String Pool 的使用情況，
JVM 提供了 -XX:+PrintStringTableStatistics 啟動引數來幫助我們獲取統計資料，
遺憾的是，只有在 JVM 退出的時候，JVM 才會將統計資料列印出來，JVM 沒有提供介面給我們實時獲取統計資料，
SymbolTable statistics:
Number of buckets : 20011 = 160088 bytes, avg 8.000
Number of entries : 10923 = 262152 bytes, avg 24.000
Number of literals : 10923 = 425192 bytes, avg 38.926
Total footprint : = 847432 bytes
Average bucket size : 0.546
Variance of bucket size : 0.545
Std. dev. of bucket size: 0.738
Maximum bucket size : 6
## 看下面這部分：
StringTable statistics:
Number of buckets : 60003 = 480024 bytes, avg 8.000
Number of entries : 4000774 = 96018576 bytes, avg 24.000
Number of literals : 4000774 = 1055252184 bytes, avg 263.762
Total footprint : = 1151750784 bytes
Average bucket size : 66.676
Variance of bucket size : 19.843
Std. dev. of bucket size: 4.455
Maximum bucket size : 84
統計資料中包含了 buckets 的數量，總的 String 物件的數量，占用的總空間，單個 bucket 的鏈表平均長度和最大長度等，
上面的資料是在 Java 8 的環境中列印出來的，Java 7 的資訊稍微少一些，主要是沒有 footprint 的資料：
StringTable statistics:
Number of buckets : 60003
Average bucket size : 67
Variance of bucket size : 20
Std. dev. of bucket size: 4
Maximum bucket size : 84
測驗 String Pool 的性能
接下來，我們來跑個測驗，測驗下 String Pool 的性能問題，并討論 -XX:StringTableSize=N 引數的作用，
我們將使用 String#intern() 往字串常量池中添加 400萬 個不同的長字串，
package com.javadoop;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;
import java.util.WeakHashMap;
public class StringTest {
public static void main(String[] args) {
test(4000000);
}
private static void test(int cnt) {
final List<String> lst = new ArrayList<String>(1024);
long start = System.currentTimeMillis();
for (int i = 0; i < cnt; ++i) {
final String str = "Very very very very very very very very very very very very very very " +
"very long string: " + i;
lst.add(str.intern());
if (i % 200000 == 0) {
System.out.println(i + 200000 + "; time = " + (System.currentTimeMillis() - start) / 1000.0 + " sec");
start = System.currentTimeMillis();
}
}
System.out.println("Total length = " + lst.size());
}
}
我們每插入 20萬 條資料，輸出一次耗時，
# 編譯
javac -d . StringTest.java
# 使用默認 table size (60013) 運行一次
java -Xms2g -Xmx2g com.javadoop.StringTest
# 設定 table size 為 400031，再運行一次
java -Xms2g -Xmx2g -XX:StringTableSize=400031 com.javadoop.StringTest
[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-wAdYC7Xn-1602205521969)(https://assets.javadoop.com/imgs/20510079/string/2.png)]
從左右兩部分資料可以很直觀看出來，插入的性能主要取決于鏈表的平均長度，當鏈表平均長度為 10 的時候，我們看到性能是幾乎沒有任何損失的，
還是那句話，根據自己的實際情況，考慮是否要設定 -XX:StringTableSize=N，還是使用默認值，
討論自建 String Pool
這一節我們來看下自己使用 HashMap 來實作 String Pool，
這里我們需要使用 WeakReference：
private static final WeakHashMap<String, WeakReference<String>> pool
= new WeakHashMap<String, WeakReference<String>>(1024);
private static String manualIntern(final String str) {
final WeakReference<String> cached = pool.get(str);
if (cached != null) {
final String value = cached.get();
if (value != null) {
return value;
}
}
pool.put(str, new WeakReference<String>(str));
return str;
}
我們使用 1000 * 1000 * 1000 作為入參 cnt 的值進行測驗，分別測驗 [1] 和 [2]：
private static void test(int cnt) {
final List<String> lst = new ArrayList<String>(1024);
long start = System.currentTimeMillis();
for (int i = 0; i < cnt; ++i) {
// [1]
lst.add(String.valueOf(i).intern());
// [2]
// lst.add(manualIntern(String.valueOf(i)));
if (i % 200000 == 0) {
System.out.println(i + 200000 + "; time = " + (System.currentTimeMillis() - start) / 1000.0 + " sec");
start = System.currentTimeMillis();
}
}
System.out.println("Total length = " + lst.size());
}
測驗結果，2G 的堆大小，如果使用 String#intern()，大概在插入 3000萬 資料的時候，開始進入大量的 FullGC，
而使用自己寫的 manualIntern()，大概到 1400萬 的時候，就已經不行了，
沒什么結論，如果要說點什么的話，那就是不要自建 String Pool，沒必要，
小結
記住有兩個 JVM 引數可以設定：-XX:StringTableSize=N、-XX:+PrintStringTableStatistics
StringTableSize，在 Java 6 中，是 1009；在 Java 7 和 Java 8 中，默認都是 60013，如果有必要請自行擴大這個值，
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/168088.html
標籤：其他