面試官：說說 String.intern() 和常量池？不同 JDK 版本有什么區別？-有解無憂

0. Background

在 JAVA 語言中有8中基本型別和一種比較特殊的型別String，這些型別為了使他們在運行程序中速度更快，更節省記憶體，都提供了一種常量池的概念，常量池就類似一個JAVA系統級別提供的快取，

8種基本型別的常量池都是系統協調的，String型別的常量池比較特殊，

它的主要使用方法有兩種：

直接使用雙引號宣告出來的String物件會直接存盤在常量池中，
如果不是用雙引號宣告的String物件，可以使用String提供的intern方法，intern 方法會從字串常量池中查詢當前字串是否存在，若不存在就會將當前字串放入常量池中

1. 常量池

1.1 常量池是什么？

JVM常量池主要分為Class檔案常量池、運行時常量池，全域字串常量池，以及基本型別包裝類物件常量池

1.1.0 方法區

方法區的作用是存盤Java類的結構資訊，當創建物件后，物件的型別資訊存盤在方法區中，實體資料存放在堆中，型別資訊是定義在Java代碼中的常量、靜態變數、以及類中宣告的各種方法，方法欄位等；實體資料則是在Java中創建的物件實體以及他們的值，

該區域進行記憶體回收的主要目的是對常量池的回收和對記憶體資料的卸載；一般說這個區域的記憶體回收率比起Java堆低得多，

1.1.1 Class檔案常量池

class檔案是一組以位元組為單位的二進制資料流，在Java代碼的編譯期間，我們撰寫的Java檔案就被編譯為.class檔案格式的二進制資料存放在磁盤中，其中就包括class檔案常量池，

class檔案常量池主要存放兩大常量：字面量和符號參考，

字面量：字面量接近java語言層面的常量概念

文本字串，也就是我們經常申明的：public String s = "abc";中的"abc"
用final修飾的成員變數，包括靜態變數、實體變數和區域變數：public final static int f = 0x101;,final int temp = 3;
而對于基本型別資料(甚至是方法中的區域變數)，如int value = https://www.cnblogs.com/javastack/p/1常量池中只保留了他的的欄位描述符int和欄位的名稱value，他們的字面量不會存在于常量池，

符號參考：符號參考主要設涉及編譯原理方面的概念

類和介面的全限定名，也就是java/lang/String;這樣，將類名中原來的".“替換為”/"得到的，主要用于在運行時決議得到類的直接參考
欄位的名稱和描述符，欄位也就是類或者介面中宣告的變數，包括類級別變數和實體級的變數
方法中的名稱和描述符，也即引數型別+回傳值

1.1.2 運行時常量池

當Java檔案被編譯成class檔案之后，會生成上面的class檔案常量池，JVM在執行某個類的時候，必須經過加載、鏈接（驗證、準備、決議）、初始化的步鄹，運行時常量池則是在JVM將類加載到記憶體后，就會將class常量池中的內容存放到運行時常量池中，也就是class常量池被加載到記憶體之后的版本，是方法區的一部分，

在決議階段，會把符號參考替換為直接參考，決議的程序會去查詢字串常量池，也就StringTable，以保證運行時常量池所參考的字串與字串常量池中是一致的，

運行時常量池相對于class常量池一大特征就是具有動態性，Java規范并不要求常量只能在運行時才產生，也就是說運行時常量池的內容并不全部來自class常量池，在運行時可以通過代碼生成常量并將其放入運行時常量池中，這種特性被用的最多的就是String.intern()，

1.1.3 字串常量池

在JDK6.0及之前版本，字串常量池存放在方法區中，在JDK7.0版本以后，字串常量池被移到了堆中了，至于為什么移到堆內，大概是由于方法區的記憶體空間太小了，在HotSpot VM里實作的string pool功能的是一個StringTable類，它是一個Hash表，默認值大小長度是1009；這個StringTable在每個HotSpot VM的實體只有一份，被所有的類共享，字串常量由一個一個字符組成，放在了StringTable上，

在JDK6.0中，StringTable的長度是固定的，長度就是1009，因此如果放入String Pool中的String非常多，就會造成hash沖突，導致鏈表過長，當呼叫String#intern()時會需要到鏈表上一個一個找，從而導致性能大幅度下降；在JDK7.0中，StringTable的長度可以通過引數指定，

字串常量池設計思想：

字串的分配，和其他的物件分配一樣，耗費高昂的時間與空間代價，作為最基礎的資料型別，大量頻繁的創建字串，極大程度地影響程式的性能
JVM為了提高性能和減少記憶體開銷，在實體化字串常量的時候進行了一些優化
- 為字串開辟一個字串常量池，類似于快取區
- 創建字串常量時，首先查看字串常量池是否存在該字串
- 存在該字串，回傳參考實體，不存在，實體化該字串并放入池中
實作的基礎
- 實作該優化的基礎是因為字串是不可變的，可以不用擔心資料沖突進行共享
- 運行時實體創建的全域字串常量池中有一個表，總是為池中每個唯一的字串物件維護一個參考,這就意味著它們一直參考著字串常量池中的物件，所以，在常量池中的這些字串不會被垃圾收集器回收

2. 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();

字串常量池的位置也是隨著jdk版本的不同而位置不同，在jdk6中，常量池的位置在永久代（方法區）中，此時常量池中存盤的是物件，在jdk7中，常量池的位置在堆中，此時，常量池存盤的就是參考了，

在jdk8中，永久代（方法區）被元空間取代了，這里就引出了一個很常見很經典的問題，看下面這段代碼，

Java 8 系列教程推薦看這里：

https://www.javastack.cn/categories/Java/Java8/

@Test
public void test(){
    String s = new String("2");
    s.intern();
    String s2 = "2";
    System.out.println(s == s2);


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

//jdk6
//false
//false

//jdk7
//false
//true

這段代碼在jdk6中輸出是false false，但是在jdk7中輸出的是false true，我們通過圖來一行行解釋，

JDK1.6

String s = new String("2");創建了兩個物件，一個在堆中的StringObject物件，一個是在常量池中的“2”物件，
s.intern();在常量池中尋找與s變數內容相同的物件，發現已經存在內容相同物件“2”，回傳物件2的地址，
String s2 = "2";使用字面量創建，在常量池尋找是否有相同內容的物件，發現有，回傳物件"2"的地址，
System.out.println(s == s2);從上面可以分析出，s變數和s2變數地址指向的是不同的物件，所以回傳false

String s3 = new String("3") + new String("3");創建了兩個物件，一個在堆中的StringObject物件，一個是在常量池中的“3”物件，中間還有2個匿名的new String(“3”)我們不去討論它們，
s3.intern();在常量池中尋找與s3變數內容相同的物件，沒有發現“33”物件，在常量池中創建“33”物件，回傳“33”物件的地址，
String s4 = "33";使用字面量創建，在常量池尋找是否有相同內容的物件，發現有，回傳物件"33"的地址，
System.out.println(s3 == s4);從上面可以分析出，s3變數和s4變數地址指向的是不同的物件，所以回傳false

JDK1.7

String s = new String("2");創建了兩個物件，一個在堆中的StringObject物件，一個是在堆中的“2”物件，并在常量池中保存“2”物件的參考地址，
s.intern();在常量池中尋找與s變數內容相同的物件，發現已經存在內容相同物件“2”，回傳物件“2”的參考地址，
String s2 = "2";使用字面量創建，在常量池尋找是否有相同內容的物件，發現有，回傳物件“2”的參考地址，
System.out.println(s == s2);從上面可以分析出，s變數和s2變數地址指向的是不同的物件，所以回傳false

String s3 = new String("3") + new String("3");創建了兩個物件，一個在堆中的StringObject物件，一個是在堆中的“3”物件，并在常量池中保存“3”物件的參考地址，中間還有2個匿名的new String(“3”)我們不去討論它們，
s3.intern();在常量池中尋找與s3變數內容相同的物件，沒有發現“33”物件，將s3對應的StringObject物件的地址保存到常量池中，回傳StringObject物件的地址，
String s4 = "33";使用字面量創建，在常量池尋找是否有相同內容的物件，發現有，回傳其地址，也就是StringObject物件的參考地址，
System.out.println(s3 == s4);從上面可以分析出，s3變數和s4變數地址指向的是相同的物件，所以回傳true，

3. String.intern()的應用

在大量字串讀取賦值的情況下，使用String.intern()會大大的節省記憶體空間，

static final int MAX = 1000 * 10000;
static final String[] arr = new String[MAX];

public static void main(String[] args) throws Exception {
    Integer[] DB_DATA = https://www.cnblogs.com/javastack/p/new Integer[10];
    Random random = new Random(10 * 10000);
    for (int i = 0; i < DB_DATA.length; i++) {
        DB_DATA[i] = random.nextInt();
    }
 long t = System.currentTimeMillis();
    for (int i = 0; i < MAX; i++) {
        //arr[i] = new String(String.valueOf(DB_DATA[i % DB_DATA.length]));
         arr[i] = new String(String.valueOf(DB_DATA[i % DB_DATA.length])).intern();
    }

 System.out.println((System.currentTimeMillis() - t) +"ms");
    System.gc();
}

運行的引數是：-Xmx2g -Xms2g -Xmn1500M 上述代碼是一個演示代碼，其中有兩條陳述句不一樣，一條是使用 intern，一條是未使用 intern，發現不使用 intern 的代碼生成了1000w 個字串，占用了大約640m 空間，

使用了 intern 的代碼生成了1345個字串，占用總空間 133k 左右，其實通過觀察程式中只是用到了10個字串，所以準確計算后應該是正好相差100w 倍，雖然例子有些極端，但確實能準確反應出 intern 使用后產生的巨大空間節省，

利用String的不變性，String.intern()方法本質就是維持了一個String的常量池，而且池里的String應該都是唯一的，這樣，我們便可以利用這種唯一性，來做一些文章了，我們可以利用池里String的物件來做鎖，實作對資源的控制，比如一個城市的某種資源同一時間只能一個執行緒訪問，那就可以把城市名的String物件作為鎖，放到常量池中去，同一時間只能一個執行緒獲得，

不當的使用：fastjson 中對所有的 json 的 key 使用了 intern 方法，快取到了字串常量池中，這樣每次讀取的時候就會非常快，大大減少時間和空間，而且 json 的 key 通常都是不變的，但是這個地方沒有考慮到大量的 json key 如果是變化的，那就會給字串常量池帶來很大的負擔，

原文鏈接：https://blog.csdn.net/gcoder_/article/details/106644312

近期熱文推薦：

1.1,000+ 道 Java面試題及答案整理(2022最新版)

2.勁爆！Java 協程要來了，，，

3.Spring Boot 2.x 教程，太全了！

4.別再寫滿屏的爆爆爆炸類了，試試裝飾器模式，這才是優雅的方式！！

5.《Java開發手冊（嵩山版）》最新發布，速速下載！

覺得不錯，別忘了隨手點贊+轉發哦！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/513739.html

標籤：Java

上一篇：java常用注解校驗引數

下一篇：DelayQueue詳解