String常量池和String#intern()

String是Java基礎的重要考點。可問的點多，而且很多點可以橫向切到其他考點，或縱向深入JVM。

本文略過了String的基本內容，重點在于String#intern()。

String常量池

String常量可能會在兩種時機進入常量池：

  1. 編譯期：通過雙引號聲明的常量（包括顯示聲明、靜態編譯優化后的常量，如”1”+”2”優化為常量”12”），在前端編譯期將被靜態的寫入class文件中的“常量池”。該“常量池”會在類加載后被載入“內存中的常量池”，也就是我們平時所說的常量池。同時，JIT優化也可能產生類似的常量。
  • 運行期：調用String#intern()方法，可能將該String對象動態的寫入上述“內存中常量池”。

時機1的行為是明確的。原理可閱讀class文件結構、類加載、編譯期即運行期優化等內容。

時機2在jdk6和jdk7中的行為不同，下面討論。

String#intern()

讀者可直接閱讀參考資料。下述總結僅為了猴子自己復習方便。

聲明

/** 
 * Returns a canonical representation for the string object. 
 * <p> 
 * A pool of strings, initially empty, is maintained privately by the 
 * class <code>String</code>. 
 * <p> 
 * When the intern method is invoked, if the pool already contains a 
 * string equal to this <code>String</code> object as determined by 
 * the {@link #equals(Object)} method, then the string from the pool is 
 * returned. Otherwise, this <code>String</code> object is added to the 
 * pool and a reference to this <code>String</code> object is returned. 
 * <p> 
 * It follows that for any two strings <code>s</code> and <code>t</code>, 
 * <code>s.intern()&nbsp;==&nbsp;t.intern()</code> is <code>true</code> 
 * if and only if <code>s.equals(t)</code> is <code>true</code>. 
 * <p> 
 * All literal strings and string-valued constant expressions are 
 * interned. String literals are defined in section 3.10.5 of the 
 * <cite>The Java&trade; Language Specification</cite>. 
 * 
 * @return  a string that has the same contents as this string, but is 
 *          guaranteed to be from a pool of unique strings. 
 */  
public native String intern();

String#intern()是一個native方法。根據Javadoc，如果常量池中存在當前字符串, 就會直接返回當前字符串. 如果常量池中沒有此字符串, 會將此字符串放入常量池中后, 再返回。

實現原理

JNI最后調用了c++實現的StringTable::intern()方法：

oop StringTable::intern(Handle string_or_null, jchar* name,  
                        int len, TRAPS) {  
  unsigned int hashValue = java_lang_String::hash_string(name, len);  
  int index = the_table()->hash_to_index(hashValue);  
  oop string = the_table()->lookup(index, name, len, hashValue);  
  // Found  
  if (string != NULL) return string;  
  // Otherwise, add to symbol to table  
  return the_table()->basic_add(index, string_or_null, name, len,  
                                hashValue, CHECK_NULL);  
}
oop StringTable::lookup(int index, jchar* name,  
                        int len, unsigned int hash) {  
  for (HashtableEntry<oop>* l = bucket(index); l != NULL; l = l->next()) {  
    if (l->hash() == hash) {  
      if (java_lang_String::equals(l->literal(), name, len)) {  
        return l->literal();  
      }  
    }  
  }  
  return NULL;  
}

在the_table()返回的hash表中查找字符串，如果存在就返回，否則加入表。

StringTable是一個固定大小的Hashtable，默認大小是1009。基本邏輯與Java中HashMap相同，也使用拉鏈法解決碰撞問題。

既然是拉鏈法，那么如果放進的String非常多，就會加劇碰撞，導致鏈表非常長。最壞情況下，String#intern()的性能由O(1)退化到O(n)。

  • jdk6中StringTable的長度固定為1009。
  • jdk7中，StringTable的長度可以通過一個參數-XX:StringTableSize指定，默認1009。

jdk6和jdk7下String#intern()的區別

引言

相信很多Java程序員都做類似String s = new String("abc");這個語句創建了幾個對象的題目。這種題目主要是為了考察程序員對字符串對象常量池的掌握。上述的語句中創建了2個對象：

  • 第一個對象，內容"abc"，存儲在常量池中。
  • 第二個對象，內容"abc"，存儲在堆中。

問題

來看一段代碼：

public static void main(String[] args) {
    String s = new String("1");
    s.intern();
    String s2 = "1";
    System.out.println(s == s2);

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

打印結果：

# jdk6下
false false
# jdk7下
false true

具體為什么稍后再解釋，然后將s3.intern();語句下調一行，放到String s4 = "11";后面。將s.intern();放到String s2 = "1";后面：

public static void main(String[] args) {
    String s = new String("1");
    String s2 = "1";
    s.intern();
    System.out.println(s == s2);

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

打印結果：

# jdk6下
false false
# jdk7下
false false

jdk6的解釋

image.png

注：圖中綠色線條代表String對象的內容指向；黑色線條代表地址指向。

jdk6中，上述的所有打印都是false。

因為jdk6的常量池放在Perm區中，和正常的Heap（指Eden、Surviver、Old區）完全分開。具體來說：使用引號聲明的字符串都是通過編譯和類加載直接載入常量池，位于Perm區；new出來的String對象位于Heap（E、S、O）中。拿一個Perm區的對象地址和Heap中的對象地址進行比較，肯定是不相同的。

Perm區主要存儲一些加載類的信息、靜態變量、方法片段、常量池等。

jdk7的解釋

在jdk6及之前的版本中，字符串常量池都是放在Perm區的。Perm區的默認大小只有4M，如果多放一些大字符串，很容易拋出OutOfMemoryError: PermGen space。

因此，jdk7已經將字符串常量池從Perm區移到正常的Heap（E、S、O）中了。

Perm區即永久代。本身用永久代實現方法區就容易遇到內存溢出；而且方法區存放的內容也很難估計大小，沒必要放在堆中管理。jdk8已經取消了永久代，在堆外新建了一個Metaspace實現方法區。

正是因為字符串常量池移到了Heap中，才產生了上述變化。

第一段代碼

image.png

先看s3和s4：

  • 首先，String s3 = new String("1") + new String("1");，生成了多個對象，s3最終指向堆中的"11"。注意，此時常量池中是沒有字符串"11"的。
  • 然后，s3.intern();，將s3中的字符串"11"放入了常量池中，因為此時常量池中不存在字符串"11"，因此常規做法與跟jdk6相同，在常量池中生成一個String對象"11"——然而，jdk7中常量池不在Perm區中了，相應做了調整：常量池中不需要再存儲一份對象了，而是直接存儲堆中的引用，也就是s3的引用地址。
  • 接下來，String s4 = "11";，"11"通過雙引號顯示聲明，因此會直接去常量池中查找，如果沒有再創建。發現已經有這個字符串了，也就是剛才通過s3.intern();存儲在常量池中的s3的引用地址。于是，直接返回s3的引用地址，s4賦值為s3的引用，s4指向堆中的"11"。
  • 最后，s3、s4指向的堆中的"11"，常量池中存儲s3的引用，滿足s3 == s4。

再看s和s2：

  • 首先，String s = new String("1");，生成了2個對象，常量池中的"1"和堆中的"1"，s指向堆中的"1"。
  • 然后，s.intern();，上一句已經在常量池中創建了"1"，所以此處什么都不做。
  • 接下來，，String s2 = "1";，常量池中有"1"，因此，s2直接指向常量池中的"1"。
  • 最后，s指向的堆中的"1"，s2指向常量池中的"1"，常量池中存儲字符串"1"，不滿足s == s2。

第二段代碼

image.png

先看s3和s4，將s3.intern();放在了String s4 = "11";后：

  • 先執行String s4 = "11";，此時，常量池中不存在"11"，因此，將"11"放入常量池，然后s4指向常量池中的"11"。
  • 再執行s3.intern();，上一句已經在常量池中創建了"11"，所以此處什么都不做。
  • 最后，s3仍指向的堆中的"11"，s4指向常量池中的"11"，常量池中存儲字符串"11"，不再滿足s3 == s4。

再看s和s2，將s.intern();放到String s2 = "1";后：

  • 先執行String s2 = "1";，之前已通過String s = new String("1");在常量池中創建了"1"，因此，s2直接指向常量池中的"1"。
  • 再執行s.intern();，常量池中有"1"，所以此處什么都不做。
  • 最后，s指向的堆中的"1"，s2指向常量池中的"1"，常量池中存儲字符串"1"，仍不滿足s == s2。

區別小結

jdk7與jdk6相比，對String常量池的位置、String#intern()的語義都做了修改：

  • 將String常量池從Perm區移到了Heap區。
  • 調用String#intern()方法時，堆中有該字符串而常量池中沒有，則直接在常量池中保存堆中對象的引用，而不會在常量池中重新創建對象。

使用姿勢

建議直接閱讀參考資料。

額外的問題

String#intern()的基本用法如下：

String s1 = xxx1.toString().intern();
String s2 = xxx2.toString().intern();
assert s1 == s2;

然而，xxx1.toString()、xxx2.toString()已經創建了兩個匿名String對象，這之后再調用String#intern()。那么，這兩個匿名對象去哪了？

估計猴子對創建對象的過程理解有問題，或許xxx1.toString()返回時還沒有將對象保存到堆上？或許String#intern()上做了什么語法糖？

后面有時間再解決吧。。。

參考：

本文鏈接：

本文鏈接：String常量池和String#intern()
作者：猴子007
出處：https://monkeysayhi.github.io
本文基于 知識共享署名-相同方式共享 4.0 國際許可協議發布，歡迎轉載，演繹或用于商業目的，但是必須保留本文的署名及鏈接。

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • ??需要說明的一點是，這篇文章是以《深入理解Java虛擬機》第二版這本書為基礎的，這里假設大家已經了解了JVM的運...
    Geeks_Liu閱讀 14,064評論 5贊 44
  • 相關概念 常量池的定義常量池(constant pool):指的是在編譯期被確定，并被保存在已編譯的.class文...
    snoweek閱讀 814評論 0贊 4
  • 不想說就什么都不要說 何必在意與自己不相關的人 ex
    車車車66閱讀 235評論 0贊 0
  • 今天當我和老婆拿著銀行卡去提款機取錢的時候，查詢余額竟然只還有一百塊錢，本來想取出錢來去買米的，這一百塊錢連米都買...
    白天有多白閱讀 316評論 0贊 0
  • 題記：謹以此文
    青梅修閱讀 370評論 0贊 1