99热99精品,国产精品美女久久,成人精品一区二区婷婷,色毛片网站,黄色电影网站社区视频,成人AV导航,12一13女人毛片,中文无码字幕视频

作者：GuoMell

來源：blog.csdn.net/gcoder_/article/details/106644312

0. Background

在 JAVA 語言中有8中基本類型和一種比較特殊的類型String。這些類型為了使他們在運行過程中速度更快，更節(jié)省內存，都提供了一種常量池的概念。常量池就類似一個JAVA系統(tǒng)級別提供的緩存。

8種基本類型的常量池都是系統(tǒng)協(xié)調的，String類型的常量池比較特殊。它的主要使用方法有兩種：

直接使用雙引號聲明出來的String對象會直接存儲在常量池中。
如果不是用雙引號聲明的String對象，可以使用String提供的intern方法。intern 方法會從字符串常量池中查詢當前字符串是否存在，若不存在就會將當前字符串放入常量池中

1. 常量池

1.1 常量池是什么？

JVM常量池主要分為Class文件常量池、運行時常量池，全局字符串常量池，以及基本類型包裝類對象常量池

1.1.0 方法區(qū)

方法區(qū)的作用是存儲Java類的結構信息，當創(chuàng)建對象后，對象的類型信息存儲在方法區(qū)中，實例數(shù)據(jù)存放在堆中。類型信息是定義在Java代碼中的常量、靜態(tài)變量、以及類中聲明的各種方法，方法字段等；實例數(shù)據(jù)則是在Java中創(chuàng)建的對象實例以及他們的值。

該區(qū)域進行內存回收的主要目的是對常量池的回收和對內存數(shù)據(jù)的卸載；一般說這個區(qū)域的內存回收率比起Java堆低得多。

1.1.1 Class文件常量池

class文件是一組以字節(jié)為單位的二進制數(shù)據(jù)流，在Java代碼的編譯期間，我們編寫的Java文件就被編譯為.class文件格式的二進制數(shù)據(jù)存放在磁盤中，其中就包括class文件常量池。

class文件常量池主要存放兩大常量：字面量和符號引用。

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

文本字符串，也就是我們經常申明的：public String s = "abc";中的"abc"
用final修飾的成員變量，包括靜態(tài)變量、實例變量和局部變量：public final static int f = 0x101;,final int temp = 3;
而對于基本類型數(shù)據(jù)(甚至是方法中的局部變量)，如int value = 1常量池中只保留了他的的字段描述符int和字段的名稱value，他們的字面量不會存在于常量池。

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

類和接口的全限定名，也就是java/lang/String;這樣，將類名中原來的".“替換為”/"得到的，主要用于在運行時解析得到類的直接引用
字段的名稱和描述符，字段也就是類或者接口中聲明的變量，包括類級別變量和實例級的變量
方法中的名稱和描述符，也即參數(shù)類型+返回值

如果您正在學習Spring Boot，推薦一個連載多年還在繼續(xù)更新的免費教程：http://blog.didispace.com/spring-boot-learning-2x/

1.1.2 運行時常量池

當Java文件被編譯成class文件之后，會生成上面的class文件常量池，JVM在執(zhí)行某個類的時候，必須經過加載、鏈接（驗證、準備、解析）、初始化的步鄹，運行時常量池則是在JVM將類加載到內存后，就會將class常量池中的內容存放到運行時常量池中，也就是class常量池被加載到內存之后的版本，是方法區(qū)的一部分。

在解析階段，會把符號引用替換為直接引用，解析的過程會去查詢字符串常量池，也就StringTable，以保證運行時常量池所引用的字符串與字符串常量池中是一致的。

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

1.1.3 字符串常量池

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

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

字符串常量池設計思想：

字符串的分配，和其他的對象分配一樣，耗費高昂的時間與空間代價，作為最基礎的數(shù)據(jù)類型，大量頻繁的創(chuàng)建字符串，極大程度地影響程序的性能
JVM為了提高性能和減少內存開銷，在實例化字符串常量的時候進行了一些優(yōu)化

為字符串開辟一個字符串常量池，類似于緩存區(qū)
創(chuàng)建字符串常量時，首先查看字符串常量池是否存在該字符串
存在該字符串，返回引用實例，不存在，實例化該字符串并放入池中

實現(xiàn)的基礎

實現(xiàn)該優(yōu)化的基礎是因為字符串是不可變的，可以不用擔心數(shù)據(jù)沖突進行共享
運行時實例創(chuàng)建的全局字符串常量池中有一個表，總是為池中每個唯一的字符串對象維護一個引用,這就意味著它們一直引用著字符串常量池中的對象，所以，在常量池中的這些字符串不會被垃圾收集器回收

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中，常量池的位置在永久代（方法區(qū)）中，此時常量池中存儲的是對象。在jdk7中，常量池的位置在堆中，此時，常量池存儲的就是引用了。

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

@Testpublic 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。我們通過圖來一行行解釋。

另外，如果您正在學習Spring Cloud，推薦一個連載多年還在繼續(xù)更新的免費教程：https://blog.didispace.com/spring-cloud-learning/

JDK1.6

String s = new String("2");創(chuàng)建了兩個對象，一個在堆中的StringObject對象，一個是在常量池中的“2”對象。
s.intern();在常量池中尋找與s變量內容相同的對象，發(fā)現(xiàn)已經存在內容相同對象“2”，返回對象2的地址。
String s2 = "2";使用字面量創(chuàng)建，在常量池尋找是否有相同內容的對象，發(fā)現(xiàn)有，返回對象"2"的地址。
System.out.println(s == s2);從上面可以分析出，s變量和s2變量地址指向的是不同的對象，所以返回false
String s3 = new String("3") + new String("3");創(chuàng)建了兩個對象，一個在堆中的StringObject對象，一個是在常量池中的“3”對象。中間還有2個匿名的new String(“3”)我們不去討論它們。
s3.intern();在常量池中尋找與s3變量內容相同的對象，沒有發(fā)現(xiàn)“33”對象，在常量池中創(chuàng)建“33”對象，返回“33”對象的地址。
String s4 = "33";使用字面量創(chuàng)建，在常量池尋找是否有相同內容的對象，發(fā)現(xiàn)有，返回對象"33"的地址。
System.out.println(s3 == s4);從上面可以分析出，s3變量和s4變量地址指向的是不同的對象，所以返回false

JDK1.7

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

3. String.intern()的應用

在大量字符串讀取賦值的情況下，使用String.intern()會大大的節(jié)省內存空間。

static final int MAX = 1000 * 10000;static final String[] arr = new String[MAX];
public static void main(String[] args) throws Exception {    Integer[] DB_DATA = 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();}

運行的參數(shù)是：-Xmx2g -Xms2g -Xmn1500M 上述代碼是一個演示代碼，其中有兩條語句不一樣，一條是使用 intern，一條是未使用 intern。發(fā)現(xiàn)不使用 intern 的代碼生成了1000w 個字符串，占用了大約640m 空間。

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

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

不當?shù)氖褂茫篺astjson 中對所有的 json 的 key 使用了 intern 方法，緩存到了字符串常量池中，這樣每次讀取的時候就會非?？?，大大減少時間和空間，而且 json 的 key 通常都是不變的。但是這個地方沒有考慮到大量的 json key 如果是變化的，那就會給字符串常量池帶來很大的負擔。

再議String-字符串常量池與String.intern()