淺談Java String內幕

 

String字符串在Java應用中使用很是頻繁，只有理解了它在虛擬機中的實現機制，才能寫出健壯的應用，本文使用的JDK版本爲1.8.0_3。

常量池

Java代碼被編譯成class文件時，會生成一個常量池（Constant pool）的數據結構，用以保存字面常量和符號引用（類名、方法名、接口名和字段名等）。

1 2 3 4 5 6

package com.ctrip.ttd.whywhy; public class Test {      public static void main(String[] args) {          String test = "test";      }  }

很簡單的一段代碼，經過命令 javap -verbose 查看class文件中 Constant pool 實現：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

Constant pool:    #1 = Methodref          #4.#13         // java/lang/Object."<init>":()V    #2 = String             #14            // test    #3 = Class              #15            // com/ctrip/ttd/whywhy/test    #4 = Class              #16            // java/lang/Object    #5 = Utf8               <init>    #6 = Utf8               ()V    #7 = Utf8               Code    #8 = Utf8               LineNumberTable    #9 = Utf8               main   #10 = Utf8               ([Ljava/lang/String;)V   #11 = Utf8               SourceFile   #12 = Utf8               test.java   #13 = NameAndType        #5:#6          // "<init>":()V   #14 = Utf8               test   #15 = Utf8               com/ctrip/ttd/whywhy/test   #16 = Utf8               java/lang/Object

經過反編譯出來的字節碼能夠看出字符串 "test" 在常量池中的定義方式：

1 2	#2 = String             #14            // test #14 = Utf8              test

在main方法字節碼指令中，0 ~ 2行對應代碼 String test = "test"; 由兩部分組成：ldc #2 和 astore_1。

1 2 3 4 5 6

// main方法字節碼指令  public static void main(java.lang.String[]);    Code:       0: ldc           #2                  // String test       2: astore_1       3: return

一、Test類加載到虛擬機時，」test」字符串在Constant pool中使用符號引用symbol表示，當調用ldc #2 指令時，若是Constant pool中索引 #2 的symbol還未解析，則調用C++底層的StringTable::intern 方法生成char數組，並將引用保存在StringTable和常量池中，當下次調用ldc #2 時，能夠直接從Constant pool根據索引 #2獲取 「test」 字符串的引用，避免再次到StringTable中查找。

二、astore_1指令將」test」字符串的引用保存在局部變量表中。

常量池的內存分配 在 JDK六、七、8中有不一樣的實現：
一、JDK6及以前版本中，常量池的內存在永久代PermGen進行分配，因此常量池會受到PermGen內存大小的限制。
二、JDK7中，常量池的內存在Java堆上進行分配，意味着常量池不受固定大小的限制了。
三、JDK8中，虛擬機團隊移除了永久代PermGen。

字符串初始化

字符串能夠經過兩種方式進行初始化：字面常量和String對象。

字面常量

1 2 3 4 5 6 7

public class StringTest {     public static void main(String[] args) {         String a = "java";         String b = "java";         String c = "ja" + "va";     } }

經過 「javap -c」 命令查看字節碼指令實現：

其中ldc指令將int、float和String類型的常量值從常量池中推送到棧頂，因此a和b都指向常量池的」java」字符串。經過指令實現能夠發現：變量a、b和c都指向常量池的 「java」 字符串，表達式 「ja」 + 「va」 在編譯期間會把結果值」java」直接賦值給c。

1 2 3 4 5 6

public class StringTest {     public static void main(String[] args) {         String a = "java";         String c = new String("java");     } }

這種狀況下，a == c 成立麼？字節碼實現以下：

其中3 ~ 9行指令對應代碼 String c = new String("java"); 實現：
一、第3行new指令，在Java堆上爲String對象申請內存；
二、第7行ldc指令，嘗試從常量池中獲取」java」字符串，若是常量池中不存在，則在常量池中新建」java」字符串，並返回；
三、第9行invokespecial指令，調用構造方法，初始化String對象。

其中String對象中使用char數組存儲字符串，變量a指向常量池的」java」字符串，變量c指向Java堆的String對象，且該對象的char數組指向常量池的」java」字符串，因此很顯然 a != c，以下圖所示：

經過 「字面量 + String對象」 進行賦值會發生什麼？

1 2 3 4 5 6 7 8

public class StringTest {     public static void main(String[] args) {         String a = "hello ";         String b = "world";         String c = a + b;         String d = "hello world";     } }

這種狀況下，c == d成立麼？字節碼實現以下：

其中6 ~ 21行指令對應代碼 String c = a + b; 實現：
一、第6行new指令，在Java堆上爲StringBuilder對象申請內存；
二、第10行invokespecial指令，調用構造方法，初始化StringBuilder對象；
三、第1四、18行invokespecial指令，調用append方法，添加a和b字符串；
四、第21行invokespecial指令，調用toString方法，生成String對象。

經過指令實現能夠發現，字符串變量的鏈接動做，在編譯階段會被轉化成StringBuilder的append操做，變量c最終指向Java堆上新建String對象，變量d指向常量池的」hello world」字符串，因此 c != d。

不過有種特殊狀況，當final修飾的變量發生鏈接動做時，虛擬機會進行優化，將表達式結果直接賦值給目標變量：

1 2 3 4 5 6 7 8

public class StringTest {     public static void main(String[] args) {         final String a = "hello ";         final String b = "world";         String c = a + b;         String d = "hello world";     } }

指令實現以下：

 

String.intern()原理

String.intern()是一個Native方法，底層調用C++的 StringTable::intern 方法，源碼註釋：當調用 intern 方法時，若是常量池中已經該字符串，則返回池中的字符串；不然將此字符串添加到常量池中，並返回字符串的引用。

1 2 3 4 5 6 7 8 9 10

package com.ctrip.ttd.whywhy; class Test {     public static void main(String args[]) {         String s1 = new StringBuilder().append("String").append("Test").toString();         System.out.println(s1.intern() == s1);           String s2 = new StringBuilder().append("ja").append("va").toString();         System.out.println(s2.intern() == s2);     } }

在 JDK6 和 JDK7 中結果不同：

一、JDK6的執行結果：false false
對於這個結果很好理解。在JDK6中，常量池在永久代分配內存，永久代和Java堆的內存是物理隔離的，執行intern方法時，若是常量池不存在該字符串，虛擬機會在常量池中複製該字符串，並返回引用，因此須要謹慎使用intern方法，避免常量池中字符串過多，致使性能變慢，甚至發生PermGen內存溢出。

二、JDK7的執行結果：true false
對於這個結果就有點懵了。在JDK7中，常量池已經在Java堆上分配內存，執行intern方法時，若是常量池已經存在該字符串，則直接返回字符串引用，不然複製該字符串對象的引用到常量池中並返回，因此在JDK7中，能夠從新考慮使用intern方法，減小String對象所佔的內存空間。

對於變量s1，常量池中沒有 「StringTest」 字符串，s1.intern() 和 s1都是指向Java對象上的String對象。
對於變量s2，常量池中一開始就已經存在 「java」 字符串，因此 s2.intern() 返回常量池中 「java」 字符串的引用。

String.intern()性能

常量池底層使用StringTable數據結構保存字符串引用，實現和HashMap相似，根據字符串的hashcode定位到對應的數組，遍歷鏈表查找字符串，當字符串比較多時，會下降查詢效率。

在JDK6中，因爲常量池在PermGen中，受到內存大小的限制，不建議使用該方法。
在JDK七、8中，能夠經過-XX:StringTableSize參數StringTable大小，下面經過幾個測試用例看看intern方法的性能。

1 2 3 4 5 6 7 8 9 10 11 12 13

public class StringTest {     public static void main(String[] args) {         System.out.println(cost(1000000));     }       public static long cost(int num) {         long start = System.currentTimeMillis();         for (int i = 0; i < num; i++) {             String.valueOf(i).intern();         }         return System.currentTimeMillis() - start;     } }

執行一百萬次intern()方法，不一樣StringTableSize的耗時狀況以下：
一、-XX:StringTableSize=1009， 平均耗時23000ms；
二、-XX:StringTableSize=10009， 平均耗時2200ms；
三、-XX:StringTableSize=100009， 平均耗時200ms；
四、默認狀況下，平均耗時400ms；

在默認StringTableSize下，執行不一樣次intern()方法的耗時狀況以下：
一、一萬次，平均耗時5ms；
二、十萬次，平均耗時25ms；
三、五十萬次，平均耗時130ms；
四、一百萬次，平均耗時400ms；
五、五百萬次，平均耗時5000ms；
六、一千萬次，平均耗時15000ms；

從這些測試數據能夠看出，儘管在Java 7以上對intern()作了細緻的優化，但其耗時仍然很顯著，若是無限制的使用intern(）方法，將致使系統性能降低，不過能夠將有限值的字符串放入常量池，提升內存利用率，因此intern()方法是一把雙刃劍。