十三、StringTable

1、String的基本特性

String : 字符串,使用一對 "" 引起來表示。

String s1 = "shuidiit";//字面量的定義方式
String s2 = new String("hello");

String聲明爲final的,不可被繼承
String實現了Serializable接口:表示字符串是支持序列化的。實現了Comparable接口:表示String可以比較大小
String在jdk8及以前內部定義了final char[] value用於存儲字符串數據。jdk9時改爲byte []

String在jdk9中存儲結構變更

http://http:/openjdk.java.net/jeps/254

結論: String再也不用charl]來存儲啦,改成了bytel]加上編碼標記,節約了一些空間。

那StringBuffer和StringBuilder是否仍無動於衷呢?

String:代表不可變的字符序列。簡稱:不可變性。

①通過字面量的方式(區別於new)給一個字符串賦值,此時的字符串值聲明在字符串常量池中。

②當對現有的字符串進行連接操作時,也需要重新指定內存區域賦值,不能使用原有的value進行賦值。

③當調用String的replace ()方法修改指定字符或字符串時,也需要重新指定內存區域賦值,不能使用原有的value進行賦值。

通過字面量的方式(區別於new)給一個字符串賦值,此時的字符串值聲明在字符串常量池中。

字符串常量池中是不會存儲相同內容的字符串的。

String的String Pool是一個固定大小的Hashtable,默認值大小長度是1009,如果放進String Pool的String非常多,就會造成Hash衝突嚴重,從而導致鏈表會很長,而鏈表長了後直接會造成的影響就是當調用String.intern時性能會大幅下降。
使用-XX: StringTableSize 可設置Stringrable的長度
在jdk6中StringTable是固定的,就是1009的長度,所以如果常量池中的字符串過多就會導致效率下降很快。StringTableSize設置沒有要求
在jdk7中, StringTable的長度默認值是60013,
jdk8開始，設置StringTable的長度的話， 1009是可設置的最小值。

2、String的內存分配

在Java語言中有8種基本數據類型和一種比較特殊的類型String。這些類型爲了使它們在運行過程中速度更快、更節省內存,都提供了一種常量池的概念。
常量池就類似一個Java系統級別提供的緩存。8種基本數據類型的常量池都是系統協調的, String類型的常量池比較特殊。它的主要使用方法有兩種

> 直接使用雙引號聲明出來的string對象會直接存儲在常量池中。

比如: string info = "atguigu.com";

> 如果不是用雙引號聲明的String對象,可以使用String提供的intern()方法。這個後面重點談

Java 6及以前,字符串常量池存放在永久代。
Java 7中Oracle的工程師對字符串池的邏輯做了很大的改變,即將字符串常量池的位置調整到Java堆內。

> 所有的字符串都保存在堆(Heap)中,和其他普通對象一樣,這樣可以讓你在進行調優應用時僅需要調整堆大小就可以了。

> 字符串常量池概念原本使用得比較多,但是這個改動使得我們有足夠的理由讓我們重新考慮在Java 7中使用string.intern()。

Java8元空間,字符串常量在堆

StringTable爲什麼要調整?

①permSize默認比較小

②永久代垃圾回收頻率低

官網

https://www.oracle.com/technetwork/java/javase/jdk7-relnotes-418459.html#jdk7changes

3、String的基本操作

Java語言規範裏要求完全相同的字符串字面量,應該包含同樣的Unicode字符序列(包含同一份碼點序列的常量),並且必須是指向同一個String類實例。

public class StringTest4 {
    public static void main(String[] args) {
        System.out.println();//2293
        System.out.println("1");//2294
        System.out.println("2");
        System.out.println("3");
        System.out.println("4");
        System.out.println("5");
        System.out.println("6");
        System.out.println("7");
        System.out.println("8");
        System.out.println("9");
        System.out.println("10");//2303
        //如下的字符串"1" 到 "10"不會再次加載
        System.out.println("1");//2304
        System.out.println("2");//2304
        System.out.println("3");
        System.out.println("4");
        System.out.println("5");
        System.out.println("6");
        System.out.println("7");
        System.out.println("8");
        System.out.println("9");
        System.out.println("10");//2304
    }
}

---------------------------------------------------------------------------------------------------------------------------

class Memory {
    public static void main(String[] args) {//line 1
        int i = 1;//line 2
        Object obj = new Object();//line 3
        Memory mem = new Memory();//line 4
        mem.foo(obj);//line 5
    }//line 9

    private void foo(Object param) {//line 6
        String str = param.toString();//line 7
        System.out.println(str);
    }//line 8
}

4、字符串拼接操作

常量與常量的拼接結果在常量池,原理是編譯期優化
常量池中不會存在相同內容的常量。
只要其中有一個是變量,結果就在堆中。變量拼接的原理是StringBuilder
如果拼接的結果調用intern ()方法,則主動將常量池中還沒有的字符串對象放入池中,並返回此對象地址。

package com.atguigu.java1;

import org.junit.Test;

/**
 * 字符串拼接操作
 * @author shkstart  [email protected]
 * @create 2020  0:59
 */
public class StringTest5 {
    @Test
    public void test1(){
        String s1 = "a" + "b" + "c";//編譯期優化：等同於"abc"
        String s2 = "abc"; //"abc"一定是放在字符串常量池中，將此地址賦給s2
        /*
         * 最終.java編譯成.class,再執行.class
         * String s1 = "abc";
         * String s2 = "abc"
         */
        System.out.println(s1 == s2); //true
        System.out.println(s1.equals(s2)); //true
    }

    @Test
    public void test2(){
        String s1 = "javaEE";
        String s2 = "hadoop";

        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";//編譯期優化
        //如果拼接符號的前後出現了變量，則相當於在堆空間中new String()，具體的內容爲拼接的結果：javaEEhadoop
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;

        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//false
        System.out.println(s3 == s7);//false
        System.out.println(s5 == s6);//false
        System.out.println(s5 == s7);//false
        System.out.println(s6 == s7);//false
        //intern():判斷字符串常量池中是否存在javaEEhadoop值，如果存在，則返回常量池中javaEEhadoop的地址；
        //如果字符串常量池中不存在javaEEhadoop，則在常量池中加載一份javaEEhadoop，並返回此對象的地址。
        String s8 = s6.intern();
        System.out.println(s3 == s8);//true
    }

    @Test
    public void test3(){
        String s1 = "a";
        String s2 = "b";
        String s3 = "ab";
        /*
        如下的s1 + s2 的執行細節：(變量s是我臨時定義的）
        ① StringBuilder s = new StringBuilder();
        ② s.append("a")
        ③ s.append("b")
        ④ s.toString()  --> 約等於 new String("ab")

        補充：在jdk5.0之後使用的是StringBuilder,在jdk5.0之前使用的是StringBuffer
         */
        String s4 = s1 + s2;//
        System.out.println(s3 == s4);//false
    }
    /*
    1. 字符串拼接操作不一定使用的是StringBuilder!
       如果拼接符號左右兩邊都是字符串常量或常量引用，則仍然使用編譯期優化，即非StringBuilder的方式。
    2. 針對於final修飾類、方法、基本數據類型、引用數據類型的量的結構時，能使用上final的時候建議使用上。
     */
    @Test
    public void test4(){
        final String s1 = "a";
        final String s2 = "b";
        String s3 = "ab";
        String s4 = s1 + s2;
        System.out.println(s3 == s4);//true
    }
    //練習：
    @Test
    public void test5(){
        String s1 = "javaEEhadoop";
        String s2 = "javaEE";
        String s3 = s2 + "hadoop";
        System.out.println(s1 == s3);//false

        final String s4 = "javaEE";//s4:常量
        String s5 = s4 + "hadoop";
        System.out.println(s1 == s5);//true

    }

    /*
    體會執行效率：通過StringBuilder的append()的方式添加字符串的效率要遠高於使用String的字符串拼接方式！
    詳情：① StringBuilder的append()的方式：自始至終中只創建過一個StringBuilder的對象
          使用String的字符串拼接方式：創建過多個StringBuilder和String的對象
         ② 使用String的字符串拼接方式：內存中由於創建了較多的StringBuilder和String的對象，內存佔用更大；如果進行GC，需要花費額外的時間。

     改進的空間：在實際開發中，如果基本確定要前前後後添加的字符串長度不高於某個限定值highLevel的情況下,建議使用構造器實例化：
               StringBuilder s = new StringBuilder(highLevel);//new char[highLevel]
     */
    @Test
    public void test6(){

        long start = System.currentTimeMillis();

//        method1(100000);//4014
        method2(100000);//7

        long end = System.currentTimeMillis();

        System.out.println("花費的時間爲：" + (end - start));
    }

    public void method1(int highLevel){
        String src = "";
        for(int i = 0;i < highLevel;i++){
            src = src + "a";//每次循環都會創建一個StringBuilder、String
        }
//        System.out.println(src);

    }

    public void method2(int highLevel){
        //只需要創建一個StringBuilder
        StringBuilder src = new StringBuilder();
        for (int i = 0; i < highLevel; i++) {
            src.append("a");
        }
//        System.out.println(src);
    }
    
    @Test
     public void test7(){
         String s1 = "javaEEhadoop";
         String s2 = new String("javaEEhadoop");

         System.out.println(s1 == s2);//false
    }
}

5、intern()的使用

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

比如: String myInfo = new String ("I love atguigu").intern ();

也就是說,如果在任意字符串上調用String. intern方法,那麼其返回結果所指向的那個類實例,必須和直接以常量形式出現的字符串實例完全相同。因此,下列表達式的值必定是true:

("a" + "b" + "c").intern() == "abc"

通俗點講, Interned String就是確保字符串在內存裏只有一份拷貝,這樣可以節約內存空間,加快字符串操作任務的執行速度。注意,這個值會被存放在字符串內部池(Strinq Intern Pool)。

題目: new String("ab")會創建幾個對象?

拓展: new String("a") + new String("b")呢?

package com.atguigu.java2;

/**
 * 題目：
 * new String("ab")會創建幾個對象？看字節碼，就知道是兩個。
 *     一個對象是：new關鍵字在堆空間創建的
 *     另一個對象是：字符串常量池中的對象"ab"。 字節碼指令：ldc
 *
 *
 * 思考：
 * new String("a") + new String("b")呢？
 *  對象1：new StringBuilder()
 *  對象2： new String("a")
 *  對象3： 常量池中的"a"
 *  對象4： new String("b")
 *  對象5： 常量池中的"b"
 *
 *  深入剖析： StringBuilder的toString():
 *      對象6 ：new String("ab")
 *       強調一下，toString()的調用，在字符串常量池中，沒有生成"ab"
 *
 * @author shkstart  [email protected]
 * @create 2020  20:38
 */
public class StringNewTest {
    public static void main(String[] args) {
//        String str = new String("ab");

        String str = new String("a") + new String("b");
    }
}

--------------------------------------------------------------------------------------------------------------------------

package com.atguigu.java2;

import org.junit.Test;

/**
 * 如何保證變量s指向的是字符串常量池中的數據呢？
 * 有兩種方式：
 * 方式一： String s = "shkstart";//字面量定義的方式
 * 方式二： 調用intern()
 *         String s = new String("shkstart").intern();
 *         String s = new StringBuilder("shkstart").toString().intern();
 *
 * @author shkstart  [email protected]
 * @create 2020  18:49
 */
public class StringIntern {
    public static void main(String[] args) {

        String s = new String("1");
        s.intern();//調用此方法之前，字符串常量池中已經存在了"1"
        String s2 = "1";
        System.out.println(s == s2);//jdk6：false   jdk7/8：false


        String s3 = new String("1") + new String("1");//s3變量記錄的地址爲：new String("11")
        //執行完上一行代碼以後，字符串常量池中，是否存在"11"呢？答案：不存在！！
        s3.intern();//在字符串常量池中生成"11"。如何理解：jdk6:創建了一個新的對象"11",也就有新的地址。
                                            //         jdk7:此時常量池中並沒有創建"11",而是創建一個指向堆空間中new String("11")的地址
        String s4 = "11";//s4變量記錄的地址：使用的是上一行代碼執行時，在常量池中生成的"11"的地址
        System.out.println(s3 == s4);//jdk6：false  jdk7/8：true
    }


}

package com.atguigu.java2;

/**
 * @author shkstart  [email protected]
 * @create 2020  22:10
 */
public class StringIntern1 {
    public static void main(String[] args) {
        //StringIntern.java中練習的拓展：
        String s3 = new String("1") + new String("1");//new String("11")
        //執行完上一行代碼以後，字符串常量池中，是否存在"11"呢？答案：不存在！！
        String s4 = "11";//在字符串常量池中生成對象"11"
        String s5 = s3.intern();
        System.out.println(s3 == s4);//false
        System.out.println(s5 == s4);//true
    }
}

總結String的intern ()的使用:

jdk1.6中,將這個字符串對象嘗試放入串池。

> 如果串池中有,則並不會放入。返回已有的串池中的對象的地址

> 如果沒有,會把此對象複製一份,放入串池,並返回串池中的對象地址

jdk1.7起,將這個字符串對象嘗試放入串池。

> 如果串池中有,則並不會放入。返回已有的串池中的對象的地址

> 如果沒有,則會把對象的引用地址複製一份,放入串池,並返回串池中的引用地址

intern()的效率測試:空間角度

package com.atguigu.java2;

import java.util.Random;

/**
 * 使用intern()測試執行效率：空間使用上
 *
 * 結論：對於程序中大量存在的字符串，尤其其中存在很多重複字符串時，使用intern()可以節省內存空間。
 *
 *
 * @author shkstart  [email protected]
 * @create 2020  21:17
 */
public class StringIntern2 {
    static final int MAX_COUNT = 1000 * 10000;
    static final String[] arr = new String[MAX_COUNT];

    public static void main(String[] args) {
        Integer[] data = new Integer[]{1,2,3,4,5,6,7,8,9,10};

        long start = System.currentTimeMillis();
        for (int i = 0; i < MAX_COUNT; i++) {
//            arr[i] = new String(String.valueOf(data[i % data.length]));
            arr[i] = new String(String.valueOf(data[i % data.length])).intern();

        }
        long end = System.currentTimeMillis();
        System.out.println("花費的時間爲：" + (end - start));

        try {
            Thread.sleep(1000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.gc();
    }
}

大的網站平臺,需要內存中存儲大量的字符串。比如社交網站,很多人都存儲:北京市、海淀區等信息。這時候如果字符串都調用 intern ()方法,就會明顯降低內存的大小。

6、StringTable的垃圾回收

7、G1中的String去重操作

http://openjdk.java.net/jeps/192

背景:對許多Java應用(有大的也有小的)做的測試得出以下結果:

> 堆存活數據集合裏面String對象佔了25%

> 堆存活數據集合裏面重複的String對象有13.5%

> String對象的平均長度是45

許多大規模的Java應用的瓶頸在於內存,測試表明,在這些類型的應用裏面,Java堆中存活的數據集合差不多25%是String對象。更進一步,這裏面差不多一半String對象是重複的,重複的意思是說:

string1. equals(string2)=true。堆上存在重複的String對象必然是一種內存的浪費。這個項目將在G1垃圾收集器中實現自動持續對重複的String對象進行去重,這樣就能避免浪費內存。

實現

當垃圾收集器工作的時候,會訪問堆上存活的對象。對每一個訪問的對象都會檢查是否是候選的要去重的String對象。
如果是,把這個對象的一個引用插入到隊列中等待後續的處理。一個去重的線程在後臺運行,處理這個隊列。處理隊列的一個元素意味着從隊列刪除這個元素,然後嘗試去重它引用的String對象。
使用一個hashtable來記錄所有的被String對象使用的不重複的char數組。當去重的時候,會查這個hashtable,來看堆上是否已經存在一個一模一樣的char數組。
如果存在, String對象會被調整引用那個數組,釋放對原來的數組的引用,最終會被垃圾收集器回收掉
如果查找失敗, char數組會被插入到hashtable,這樣以後的時候就可以共享這個數組了。

命令行選項

UseStringDeduplication (bool):開啓String去重,默認是不開啓的,需要手動開啓。
PrintStringDeduplicationStatistics (bool) :打印詳細的去重統計信息
StringDeduplicationAgeThreshold (uintx):達到這個年齡的String對象被認爲是去重的候選對象

十三、StringTable

十五、垃圾回收相關算法

(9)Mycat常用分片規則

十三、StringTable

二、類加載子系統三、運行時數據區概述及線程四、程序計數器(PC 寄存器)

十四、垃圾回收概述

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結