Java 常數池詳解之字串常數池實現程式碼

2022-12-27 14:01:52

1.1:字串常數池在Java記憶體區域的哪個位置？
1.2:字串常數池是什麼？
1.3 字串常數池生成的時機？
如何將String物件放入到常數池
String 物件程式碼案例解析
new string(“abc”)建立了幾個物件
解析public native String intern() 方法
Integer 物件程式碼案例解析
為啥Integer i1 =10 跟Integer.valueOf(10) 是相等的？
為啥Integer i1 =128 跟Integer.valueOf(128) 是不相等的？

在Java的記憶體分配中，總共3種常數池：

Java 常數池詳解（二）class檔案常數池和 Java 常數池詳解（三）class執行時常數池

1.字串常數池(String Constant Pool）

在JDK1.7之前執行時常數池邏輯包含字串常數池存放在方法區, 此時hotspot虛擬機器器對方法區的實現為永久代
在JDK1.7 字串常數池被從方法區拿到了堆中, 這裡沒有提到執行時常數池,也就是說字串常數池被單獨拿到堆,執行時常數池剩下的東西還在方法區, 也就是hotspot中的永久代
在JDK1.8 hotspot移除了永久代用元空間(Metaspace)取而代之, 這時候字串常數池還在堆, 執行時常數池還在方法區, 只不過方法區的實現從永久代變成了元空間(Metaspace)

1.1:字串常數池在Java記憶體區域的哪個位置？

在JDK6.0及之前版本，字串常數池是放在Perm Gen區(也就是方法區)中；
在JDK7.0版本，字串常數池被移到了堆中了。至於為什麼移到堆內，大概是由於方法區的記憶體空間太小了。
（堆內是可以進行回收的，然後方法區也是能回收的，但是本身區域記憶體比較少，如果用的字串常數太多了，也會拋java.lang.OutOfMemoryError:PermGenspace 異常）

1.2:字串常數池是什麼？

在HotSpot VM裡實現的string pool功能的是一個StringTable類，它是一個Hash表，預設值大小長度是1009；這個StringTable在每個HotSpot VM的範例只有一份，被所有的類共用。字串常數由一個一個字元組成，放在了StringTable上。
在JDK6.0中，StringTable的長度是固定的，長度就是1009，因此如果放入String Pool中的String非常多，就會造成hash衝突，導致連結串列過長，當呼叫String#intern()時會需要到連結串列上一個一個找，從而導致效能大幅度下降；
在JDK7.0中，StringTable的長度可以通過引數指定：

-XX:StringTableSize=66666`

1.3 字串常數池生成的時機？

String a = "a";

全域性字串池裡的內容是在類載入完成，經過驗證，準備階段之後在堆中生成字串物件範例，然後將該字串物件範例的參照值存到string pool中（記住：string pool中存的是參照值而不是具體的範例物件，具體的範例物件是在堆中開闢的一塊空間存放的）

如何將String物件放入到常數池

“abc” 雙引號String 物件會自動放入常數池
呼叫String的intern 方法也會將物件放入到常數池中

String 物件程式碼案例解析

public static void main(String[] args) {
    String a = "a";
    String b = "b";
    String c = "a" + "b";
    //生成兩個物件 一個"ab" ，一個新的String 物件value 值是ab
    //public String(String original) {
    //   this.value = original.value;
    //   this.hash = original.hash;
    //}
    String d = new String("ab"); 
    
    String e = a + "b";
    String f = a + b;
    String g = "ab";
    
   System.out.println(e == c);
   System.out.println(c == d);
   System.out.println(f == c);
   System.out.println(g == c);
   
   String e1 = e.intern();
   String c2 = c.intern();
   System.out.println(e1 == c2);
   System.out.println(e1 == c);
}

//執行結果
false
false
false
true
true
true

String c =“a” + “b” 和String c = “a” + b （String b= “b”）的區別

String b = "b";
String c = "a" + "b"; 等價於 String c ="ab"
String c1 = "a" + b; 
 
// java 反編譯的結果  
 0 ldc #3 <b> //load constant  載入常數 "b"
 2 astore_1   // 存入變數1中
 3 ldc #4 <ab> //自動識別了 
 5 astore_2
 6 new #7 <java/lang/StringBuilder>
 9 dup
10 invokespecial #8 <java/lang/StringBuilder.<init>>
13 ldc #2 <a>
15 invokevirtual #9 <java/lang/StringBuilder.append>
18 aload_1
19 invokevirtual #9 <java/lang/StringBuilder.append>
22 invokevirtual #10 <java/lang/StringBuilder.toString>
25 astore_3
26 return

(1) “a”+“b” 編譯器自動識別了變成了 “ab” => 3 ldc #4
(2) “a” + b（變數）

先new 了StringBuilder 物件，並初始化init
然後bulider.append(“a”)
從變數1（b）中取出值"b"
然後執行了bulider.append(“b”)
最後執行了builder.toString() 方法給變數3（ c1）進行賦值

new string(“abc”)建立了幾個物件

答案：是兩個，new string(xxxx)方法，xxxx傳入的是String物件。說明xxxx也是String物件。

	 public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }

String 是一個final 型別物件是不會變化的，如果發生變化，說明其實是新的物件。

public final class String

解析public native String intern() 方法

如果常數池中存在當前字串, 就會直接返回當前字串. 如果常數池中沒有此字串, 會將此字串放入常數池中後, 再返回

native實現程式碼:

openjdk7jdksrcsharenativejavalangString.c

Java_java_lang_String_intern(JNIEnv *env, jobject this) 
{ 
    return JVM_InternString(env, this); 
}

openjdk7hotspotsrcsharevmprimsjvm.h

JNIEXPORT jstring JNICALL 
JVM_InternString(JNIEnv *env, jstring str);

openjdk7hotspotsrcsharevmprimsjvm.cpp

JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str)) 
  JVMWrapper("JVM_InternString"); 
  JvmtiVMObjectAllocEventCollector oam; 
  if (str == NULL) return NULL; 
  oop string = JNIHandles::resolve_non_null(str); 
  //呼叫StringTable::intern 方法
  oop result = StringTable::intern(string, CHECK_NULL);
  return (jstring) JNIHandles::make_local(env, result); 
JVM_END

openjdk7hotspotsrcsharevmclassfilesymbolTable.cpp

oop StringTable::intern(Handle string_or_null, jchar* name, int len, TRAPS) { 
  //根據名字找到對應hash下標
  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); 
}

openjdk7hotspotsrcsharevmclassfilesymbolTable.cpp

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; 
}

1.它的大體實現結構就是:JAVA 使用 jni 呼叫c++實現的StringTable的intern方法。

2.要注意的是，String的String Pool是一個固定大小的Hashtable，預設值大小長度是1009，如果放進String Pool的String非常多，就會造成Hash衝突嚴重，從而導致連結串列會很長，而連結串列長了後直接會造成的影響就是當呼叫String.intern時效能會大幅下降。

Interger 包裝類的池化技術

public final class Integer extends Number implements Comparable<Integer> {
   
    @Native public static final int   MIN_VALUE = 0x80000000;

  
    @Native public static final int   MAX_VALUE = 0x7fffffff;

    //快取-128到127的值在IntegerCache裡面，可以進行共用
    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];
    
        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;
    
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
    
            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }
    
        private IntegerCache() {}
    }
    
    public static Integer valueOf(int i) {
        //是不是在-128到127裡面，不是的話就生成新的Integer
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
}

Integer 物件程式碼案例解析

public void test(){
    Integer i1 = 10;
    Integer i2 = 10;
    Integer i3 = new Integer(10);//新物件
    Integer i4 = new Integer(10);//新物件
    Integer i5 = Integer.valueOf(10);//從快取池裡面獲取。
    Integer i6 = Integer.valueOf(128);
    Integer i7 = 128;

    System.out.println(i1 == i2); // true
    System.out.println(i2 == i3); // false
    System.out.println(i3 == i4); // false
    System.out.println(i1 == i5); // true
    System.out.println(i6 == i7); // false
}

//執行結果：
true
false
false
true
false

為啥Integer i1 =10 跟Integer.valueOf(10) 是相等的？

因為Integer i1 = 10 底層原理是 Integer i1 = Integer.valueof(10)

  //Integer i1 =10 反編譯的結果
  0 bipush 10
  2 invokestatic #14 <java/lang/Integer.valueOf> //呼叫了Integer.valueof方法
  5 astore_1

為啥Integer i1 =128 跟Integer.valueOf(128) 是不相等的？

因為超過-128～127 這個範圍，就不在快取池裡面，不能共用都是新new 出來的

public static Integer valueOf(int i) {
        //是不是在-128到127裡面，不是的話就生成新的Integer
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

問題：包裝類物件池是不是 JVM 常數池的一種？

包裝類的物件池是池化技術的應用，並非是虛擬機器器層面的東西，而是 Java 在類封裝裡實現的，IntegerCache 是 Integer在內部維護的一個靜態內部類，用於物件快取。
Integer 物件池在底層實際上就是一個變數名為 cache 的陣列，裡面包含了 -128 ～ 127 的 Integer 物件範例。使用物件池的方法就是通過 Integer.valueOf() 返回 cache 中的物件，像 Integer i = 10這種自動裝箱實際上也是呼叫 Integer.valueOf() 完成的
這和常數池中字面量的儲存有很大區別，Integer 不需要顯示地出現在程式碼中才新增到池中，初始化時它已經包含了所有需要快取的物件

到此這篇關於Java 常數池詳解之字串常數池的文章就介紹到這了,更多相關java字串常數池內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！