jvm-StringTable详解

参考

尚硅谷：宋红康（b站视频）

一、String的基本特性

1.1 字符串特征

字符串，用""引起来表示

String s1 = “mogublog” ; // 字面量的定义方式，声明在字符串常量池

String s2 = new String(“moxi”); // new 对象的方式

声明为final的不可被继承的
实现了Serializable接口，表示支持序列化
实现了Comparable接口，表示可以比较大小

1.2 jdk里面的String存储变化

jdk8及以前，内部定义了final char[] value用于存储字符串数据
jdk9类型更改：private final char value[];–>private final byte[] value;

char数组每个字符占两个字节16位，String是堆空间的主要部分，大部分是拉丁字符，占一个字节，节省空间

String再也不用char[] 来存储，改成了byte [] 加上编码标记

StringBuffer，StringBuilder同样做了修改

1.3 String代表不可变的字符序列（不可变性）

当字符串重新赋值，需要重写指定内存区域赋值，不能使用原有的value进行赋值
当调用String的replace方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。

这里new了一个Stringbuilder之后还需要toString所以相当于新建了一个对象，内存从新分配
当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能对使用原有的value进行赋值

1.4 字符串常量池中不会存储相同的字符串

String的String Pool是一个固定大小的Hashtable，默认值大小长度是1009。如果放进String Pool的String非常多，就会造成Hash冲突严重，从而导致链表会很长，而链表长了后直接会造成的影响就是当调用String.intern()方法时性能会大幅下降。
使用-XX:StringTablesize可设置StringTable的长度
在JDK6中StringTable是固定的，就是1009的长度，所以如果常量池中的字符串过多就会导致效率下降很快，StringTablesize设置没有要求
在JDK7中，StringTable的长度默认值是60013，StringTablesize设置没有要求
在JDK8中，StringTable的长度默认值是60013，StringTable可以设置的最小值为1009

tips：设置的长度带一点执行速度会快很多，可以通过参数设置

# jdk7、8后最小值必须大于等于1009
-XX:StringTablesize

1.5 StringTable为什么要调整

因为字符串放在永久代中回收效率很低。老年代或永久代空间不足才会触发fullGC。
开发中会创建大量字符串，回收效率低，导致永久代内存不足。JDK7放到堆中，能及时进行回收。
永久代默认情况下比较小，大量字符串容易导致OOM。
堆中空间足够大，字符串可被及时回收

二、String的内存分配

Java语言中有8种基本数据类型和一种比较特殊的类型String，这些类型为了使他们再运行过程中速度更快，更节省内存，都提供了一种常量池的概念

String的常量池比较特殊，主要使用方法有两种
a. 直接使用双引号，声明出来的String对象会直接存储在常量池中
b. 如果不是双引号声明的String对象，可以使用String提供的intern()方法

jdk6及之前，字符串常量池存在永久代，与应用程序创建的其他对象一起分配。
jdk7中，字符串常量池调整到Java堆中(调优时仅需调整堆大小就可以)
Jdk8中，元空间，字符串常量在堆

三、String的基本操作

3.1 String的基本操作：

Java语言规范要求完全相同的字符串字面量，应该包含同样的Unicode字符序列，包含同一份码点序列的常量，并且必须指向同一个String类实例

String的基本操作

3.2 字符串拼接操作

常量与常量的拼接结果在常量池，原理是编译期优化

@Test
    public void test1(){
    
    
        //编译期优化：等同于"abc"
        String s1 = "a" + "b" + "c";
        //"abc"一定是放在字符串常量池中，将此地址赋给s2
        String s2 = "abc";
        /*
         * 最终.java编译成.class,再执行.class
         * String s1 = "abc";
         * String s2 = "abc"
         */
        System.out.println(s1 == s2); //true
        System.out.println(s1.equals(s2)); //true
    }

常量池中不存在相同内容的常量（hashtable）,只要有一个变量，拼接结果就在堆中（常量池以外的堆），变量的拼接原理是StringBuilder

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

Final修饰符

/*
    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
    }

对比用+号拼接字符串和StringBuilder.append操作

拼接10万次，+号4000，append用了7毫秒，原因是+号每次循环创建一个StringBuilder，还要通过toString创建一个String对象

内存中由于创建了较多的对象，内存占用更大，如果需要GC需要花费额外的时间

改进空间：StringBuilder默认是16长度的char型数组，不够的时候会扩容，可以一次建一个比较大长度的数组。

 /*
    体会执行效率：通过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);
    }

四、intern操作

4.1 如何保证变量s指向的是字符串常量池中的数据呢？

String s = “shkstart”;//字面量定义的方式
调用intern()

String s = new String(“shkstart”).intern();

String s = new StringBuilder(“shkstart”).toString().intern();

确保字符串在内存里只有一份拷贝，这样可以节约内存空间，加快字符串操作任务的执行速度，注意，这个值会被存放在字符串内部池。（String intern pool）

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"

对象6，StringBuilder的toString() new String(“ab”)
a. toString()的调用，在字符串常量池中，没有生成"ab"

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

6个对象

4.2 经典案例

4.2.1 案例1

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");
        //调用此方法之前，字符串常量池中已经存在了"1"
        s.intern();
        String s2 = "1";
        //jdk6：false   jdk7/8：false
        System.out.println(s == s2);

        //s3变量记录的地址为：new String("11")
        String s3 = new String("1") + new String("1");
        //执行完上一行代码以后，字符串常量池中，是否存在"11"呢？答案：不存在！！
        //在字符串常量池中生成"11"。如何理解：jdk6:创建了一个新的对象"11",也就有新的地址。
        s3.intern();
        // jdk7:此时常量中并没有创建"11",而是创建一个指向堆空间中new String("11")的地址
        //s4变量记录的地址：使用的是上一行代码代码执行时，在常量池中生成的"11"的地址
        String s4 = "11";
        //jdk6：false  jdk7/8：true
        System.out.println(s3 == s4);
    }
}

不同版本的内存指向解析：

JDK6
JDK7/8

4.2.2 案例2

package com.atguigu.java2;

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

4.3 补充

jdk1.6中，s.intern() 将这个字符串对象放入串池

如果串池中有，则并不会放入，返回已有串池中的对象的地址，

如果没有，会把对象复制一份，放入串池，并返回串池中的对象地址

jdk1.7起，s.intern() 将这个字符串对象尝试放入串池

如果串池中有，则并不会放入，返回已有的串池中的对象的地址

如果没有，则会把对象的引用地址复制一份，放入串池，并返回串池中的引用地址

在这里插入图片描述

在这里插入图片描述
intern（）的效率测试:

package com.atguigu.java2;

/**
 * 使用intern()测试执行效率：空间使用上
 * <p>
 * 结论：对于程序中大量存在存在的字符串，尤其其中存在很多重复字符串时，使用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();
    }
}

直接 new String ：由于每个 String 对象都是 new 出来的，所以程序需要维护大量存放在堆空间中的 String 实例，程序内存占用也会变高

使用 intern() 方法：由于数组中字符串的引用都指向字符串常量池中的字符串，所以程序需要维护的 String 对象更少，内存占用也更低

对于程序中大量使用存在的字符串时，尤其存在很多已经重复的字符串时，使用intern()方法能够节省内存空间。

大的网站平台，需要内存中存储大量的字符串。比如社交网站，很多人都存储：北京市、海淀区等信息。这时候如果字符串都调用intern() 方法，就会很明显降低内存的大小。

五、关于String的垃圾回收

StringTable的垃圾回收（-XX:+PrintStringTableStatistics）

5.1 G1中String去重操作

背景：对许多Java应用，做的测试结果如下

堆存活数据集合里面String对象占了25%

堆存活数据集合里面重复的String对象有13.5%

String对象的平均长度是45

许多大规模的Java应用的瓶颈在于内存，一半String对象是重复的，str1.equals(str2)= true
G1垃圾收集器中实现自动持续对重复的String对象进行去重，这样能避免内存浪费。

六、String 去重的的具体实现

当垃圾收集器工作的时候，会访问堆上存活的对象。对每一个访问的对象都会检查是否是候选的要去重的String对象。
如果是，把这个对象的一个引用插入到队列中等待后续的处理。一个去重的线程在后台运行，处理这个队列。处理队列的一个元素意味着从队列删除这个元素，然后尝试去重它引用的String对象。
使用一个Hashtable来记录所有的被String对象使用的不重复的char数组。当去重的时候，会查这个Hashtable，来看堆上是否已经存在一个一模一样的char数组。
如果存在，String对象会被调整引用那个数组，释放对原来的数组的引用，最终会被垃圾收集器回收掉。
如果查找失败，char数组会被插入到Hashtable，这样以后的时候就可以共享这个数组。

七、总结

感谢大家阅、互相学习；
感谢尚硅谷提供的学习资料；
有问题评论或者发邮箱；
gitee：很多代码仓库；
[email protected]

参考

一、String的基本特性

1.1 字符串特征

1.2 jdk里面的String存储变化

1.3 String代表不可变的字符序列（不可变性）

1.4 字符串常量池中不会存储相同的字符串

1.5 StringTable为什么要调整

二、String的内存分配

三、String的基本操作

3.1 String的基本操作：

3.2 字符串拼接操作

四、intern操作

4.1 如何保证变量s指向的是字符串常量池中的数据呢？

4.2 经典案例

4.2.1 案例1

4.2.2 案例2

4.3 补充

五、关于String的垃圾回收

5.1 G1中String去重操作

六、String 去重的的具体实现

七、总结

猜你喜欢