JVM StringTable

已于 2023-05-15 17:47:15 修改
阅读量478 收藏
点赞数
分类专栏： Java JVM 文章标签： jvm java
于 2023-05-15 16:46:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hn_lzh2014/article/details/130682492
版权
Java 同时被 2 个专栏收录
46 篇文章 0 订阅
订阅专栏
JVM
15 篇文章 0 订阅
订阅专栏
本文详细介绍了Java中的String类的基本特性，包括其不可变性、内存分配方式，特别是字符串常量池的运作机制。提到了intern()方法的作用，以及不同版本JDK中字符串常量池的位置变化。还讨论了字符串拼接的效率问题和垃圾回收对String对象的影响。
摘要由CSDN通过智能技术生成

String的基本特性

  • String： 字符串，使用一对 " "引起来表示，

String s1 = "doubily"; // 字面量的含义

String s2 = new String("doubily");

  • String 的声明为 final的，不可被继承
  • String 实现了 Serializable 接口: 表示字符串是支持序列化的，实现了 Comparable接口: 表示 String 可以比较大小
  • String 1.9 再也不用 char[] 来存储了，改为了 byte[] 加上编码标记，节约了一些空间
  • String 代表不可变的字符序列，当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的 value 进行赋值，当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的 value 赋值。 当调用 String 的 replace() 方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的 value 进行赋值
public class StringTest1 {

    public static void main(String[] args) {
        test1();
        test2();
        test3();
    }
    public static void test1() {
        String s1 = "abc";  // 字面量定义的方式,"abc" 存储在字符串常量池
        String s2 = "abc";

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


    public static void test2() {
        String s1 = "abc";
        String s2 = "abc";
        s2 += "def";
        System.out.println(s1);
        System.out.println(s2);
    }

    public static void test3() {
        String s1 = "abc";
        String s2 = s1.replace('a','m');
        System.out.println(s1);
        System.out.println(s2);
    }
}
  • 通过字面量的方式(区别于 New) 给一个字符串赋值，此时的字符串值声明在字符常量池中

字符串常量池是不会存储相同内容的字符串:

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

String的内存分配

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

1. 直接使用双引号声明出来的 String 对象会直接存储在常量池种

        String info = "doubily";

2. 如果不是使用双引号声明的 String 对象，可以使用 String 提供的 Intern() 方法

  • java 6 以及之前，字符串常量池存放在永久代
  • java 7及以后,  将字符串常量池调整到 java 堆内
/**
 * 设置永久代大小
 * jdk6: --XX:PermSize=6m --XX:MaxPermSize=6m -Xms6m -Xmx6m
 * jdk8: MetaspaceSize=6m --XX:MaxMetaspaceSize=6m -Xms6m -Xmx6m
 */
public class StringTest3 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();

        short i = 0;
        while (true){
            set.add(String.valueOf(i++).intern());
        }
    }
}

StringTable 为什么要调整:

  • permSize 默认比较小
  • 永久代垃圾回收频率低

字符串拼接操作

  • 常量与常量的拼接结果在常量池，原理是编译期优化
  • 常量池种不会存在相同内容的常量
  • 只要其中有一个是变量，结果就在堆中，变量拼接的原理是StringBuilder
  • 如果拼接的结果调用 intern() 方法，则主动将常量池中还没有的字符串对象放入池中，并返回此对象地址
public class StringTest5 {
    public static void main(String[] args) {
        test1();
    }
    public static void test1(){
        String s1 = "a" + "b" + "c";

        String s2 = "abc"; // 一定是放在字符串常量池中，将此地址

        System.out.println(s1 == s2); // true 编译期优化
        System.out.println(s1.equals(s2));
    }

    public static void test2(){
        String s1 = "javaEE";
        String s2 = "hadoop";
        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";
        // 如果拼接符号的前后出现了变量，则相当于在堆空间中 new String()
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;

        System.out.println(s3 == s4); // true 编译期优化
        System.out.println(s3 == s5);
        System.out.println(s3 == s6);
        System.out.println(s3 == s7);
        System.out.println(s5 == s6);
        System.out.println(s5 == s7);
        System.out.println(s6 == s7);

        // intern 判断字符串常量池中是否存在值，如果存在，则返回常量池中的地址，如果不存在，则在常量池中加载一份，并返回对象地址
        String s8 = s6.intern();
        System.out.println(s3 == s8);
    }

    public static void test3(){
        String s1 = "a";
        String s2 = "b";
        String s3 = "ab";
        /**
         * StringBuilder s = new StringBuilder();
         * s.append("a");
         * s.append("b");
         * s.toString(); 。类似与 new String()
         * 在jdk5.0 之后使用 StringBuilder， 在jdk5.0 之后使用 StringBuffer
         */
        String s4 = s1 + s2;
        System.out.println(s3 == s4);
    }
    public static void test4(){
        final String s1 = "a";
        final String s2 = "b";
        String s3 = "ab";
        // 如果拼接符号左右两边都是字符串常量或常量引用，则仍然使用编译期优化，即非 StringBuilder 方法
        // 针对 final修饰类、方法、基本数据类型、引用数据类型的量的结构，能使用 final 建议使用上
        String s4 = s1 + s2;
        System.out.println(s3 == s4);
    }

    public void method1(int highLevel){
        String src = "";
        for (int i = 0; i < highLevel; i++){
            src = src + "a"; // 每次循环都会创建一个StringBuilder, string
        }
    }

    /**
     * 通过 StringBuilder 的 append() 的方式添加字符串的效率要远高于使用 String 的字符串拼接方式
     * StringBuilder 的 append() 的方法自始至终只创建一个 StringBuilder 对象
     * String 字符串拼接方式:创建多个 StringBuilder 和 String 对象
     * 使用 String 的字符串拼接方式: 内存中由于创建了较多的 StringBuilder 和 String ，占用大量内存
     * @param highLevel
     */
    public void method2(int highLevel){
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < highLevel; i++){
            sb.append("a"); // 每次循环都会创建一个StringBuilder, string
        }
    }
}

intern() 的使用

  • 如果不是用双引号声明的 String 对象，可以使用 String 提供的 intern 方法: intern 方法会从字符串常量池中查询当前字符串是否存在，若不存在就会将当前字符串放入常量池中。比如: String myInfo = new String("doubily").intern();
  • 在任意字符串上调用 String.intern 方法，那么其返回结果所指向的那个类实例，必须和直接以常量形式出现的字符串完全相同。因此 ("a" + "b" +"c").intern() == "abc" 为 true;
  • Interned String 就是确保字符串在内部里只有一份拷贝，这样可以节约内存空间，加快字符串操作任务的执行速度。注意，这个值会被存放在字符串内部池(String Intern Pool)
  • jdk1.6 中，如果串池中有，则并不会放入。返回已有的串池中的对象地址，如果没有，会把此对象复制一份，放入串池，并返回串池中的对象地址
  • jdk1.7起，如果串池中有，则并不会放入。返回已有的串池中的对象地址，如果没有，则会把对象引用地址复制一份，放入串中，并返回串池中的引用地址
/**
 * String s = "doubily"; // 字面量定义的方式
 * String s = new String("doubily").intern();
 */
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  s 堆空间的引用地址 s2 常量池地址

        String s3 = new String("1") + new String("1"); // s3 变量记录的地址为: new String("11") 字符串常量池中不存在 11
        s3.intern(); // 在字符串常量池中生成 "11", jdk6： 创建了一个新的对象 "11",也就有了新的地址 jdk7: 常量池记录了创建 "11" 的地址
        String s4 = "11"; // 使用的是上一行代码执行时，在常量池中生成的 "11" 的地址
        System.out.println(s3 == s4);// jdk6 false jdk7/8: true

        String s5 = new String("1") + new String("1"); // String("11")
        String s6 = "11";  // 常量池中生成对象 "11"
        s5.intern();
        String s7 = s5.intern();
        System.out.println(s5 == s6);// jdk6 false jdk7/8: false
        System.out.println(s7 == s6); // true

    }
}

new String("ab") 会创建几个对象:

public class StringNewTest {
    public static void main(String[] args) {

        /**
         * 2 个对象，看字节码
         *  0 new #2 <java/lang/String> 一对象是通过 new 在堆空间创建的
         *  3 dup
         *  4 ldc #3 <ab> 字符串常量池中的对象 ldc
         *  6 invokespecial #4 <java/lang/String.<init> : (Ljava/lang/String;)V>
         *  9 astore_1
         * 10 return
         */
        // String str = new String("ab");
        /**
         *  0 new #2 <java/lang/StringBuilder> new StringBuilder()
         *  3 dup
         *  4 invokespecial #3 <java/lang/StringBuilder.<init> : ()V>
         *  7 new #4 <java/lang/String> new String("a")
         * 10 dup
         * 11 ldc #5 <a> 常量池中的 "a"
         * 13 invokespecial #6 <java/lang/String.<init> : (Ljava/lang/String;)V>
         * 16 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
         * 19 new #4 <java/lang/String> new String("b")
         * 22 dup
         * 23 ldc #8 <b> 常量池中的 "b"
         * 25 invokespecial #6 <java/lang/String.<init> : (Ljava/lang/String;)V>
         * 28 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
         * 31 invokevirtual #9 <java/lang/StringBuilder.toString : ()Ljava/lang/String;> // new String("ab") 字符串常量池中不存在 ab
         * 34 astore_1
         * 35 return
         */
        String str = new String("a") + new String("b");
    }
}

熟悉1:

Intern() 空间测试:

/**
 * 对于字符串尤其存在很多重复字符串时，使用 intern() 可以节省很多空间
 */
public class StringExer2 {
    static final int MAX_COUNT = 1000 * 10000;

    static final String[] arr = new String[MAX_COUNT];

    public static void main(String[] args) throws InterruptedException {
        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));
        Thread.sleep(10000000);
    }
}

StringTable 的垃圾回收

/**
 * 垃圾回收 -Xms15m -Xmx15m -XX:+PrintGCDetails -XX:+PrintStringTableStatistics
 */
public class StringGCTest {
    public static void main(String[] args) {
        for (int j = 0; j < 1000000; j++) {
            String.valueOf(j).intern();
        }
    }
}

G1 中的 String 去重操作

背景:

  • 堆存活数据集合里面 String 对象占了 25%
  • 堆存活数据集合里面重复的 String 队友有 13.5%
  • String 对象的平均长度是 45

实现:

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

命令行:

  • UseStringDeduplication(bool): 开启 String 去重，默认是不开启的，需要手动开启
  • PrintStringDeduplicationStatistics(bool): 打印详细的去重统计信息
  • StringDeduplicationAgeThreshold(uintx): 达到这个年龄的 String 对象被认为是去重的候选对象
逆流丶石头
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JVM 虚拟机中StringTable
qq_40990836的博客
06-14 191
String 的基本特性 String字符串，使用一对 '" 引起来表示 String s1 = “str”； // 字面量的定义方式、 String s2 = new String(“hello”); String 声明为 final的 不可以被继承 String 实现了 Serializable 接口： 表示字符串是支持序列化的，实现了Comparable 接口，表示String 可以比较大小 String 在 jdk 8 级以前内部定义了 final char[] value 用于存储字符串数
JVM_03 StringTable
m0_51118873的博客
11-25 196
JVM_03 StringTable
JVM - 【字符串常量池】-XX:StringTableSize
⚡
09-14 1149
字符串常量池 - StringTable 一：配置常量池大小 -XX:StringTableSize=60013 JDK1.6默认为1009，JDK1.7之后默认为60013，字符串常量池底层为HashTable，合理增大常量池大小会解决Hash冲突问题 JDK1.8开始1009是可以设置的最小值 二：测试（常量池大小对执行效率的影响） package xyz.xx.chapter_string; import java.io.BufferedReader; import java.io.F
JVM参数：-XX:StringTableSize
lidf1992的博客
07-14 1727
通过笨神的分享整理笔记： 常量池底层使用StringTable数据结构保存字符串引用，实现和HashMap类似，根据字符串的hashcode定位到对应的数组，遍历链表查找字符串，当字符串比较多时，会降低查询效率。 -XX:StringTableSize 在我们调用String.intern的时候会往hashtable里插入一项，这个table就是stringtable 使用最多的场景是序列化
JVM-StringTable
weixin_43868966的博客
02-07 274
文章目录前言一、String特性二、String的基本操作2.1 添加到常量池2.2 拼接 前言 String是java语言最重要的类，也是最重要的数据类型。 但是你真的了解String吗？试从jvm角度分析String 以及深度剖析String类的常见面试题 一、String特性 声明方式： （1）字面量 即String a = “a”; （2）对象式 String a = new String(“a”); 经过堆的学习，new出来的肯定都是去堆中创建对象。 而字面量方式会去堆中的字符串常量池引用对象，
JVM中StringTable详解
写写平时的技术与感想
04-21 2021
String在JDK9中存储结构变更：官方网站说明：JEP 254: Compact Strings (java.net) 对官方中的内容说明进行翻译： 动机目前类的实现将字符存储在一个数组中，每个字符使用两个字节（16位）。从许多不同的应用中收集到的数据表明，字符串是堆使用的主要组成部分，此外，大多数字符串对象只包含Latin-1字符。这些字符只需要一个字节的存储空间，因此这些字符串对象的内部字符数组中有一半的空间没有被使用。 说明 我们建议将类的内部表示方法从字符数组改为字节数组加编码标志域。新的Str
java string table_聊聊jvm的StringTable及SymbolTable
weixin_39851914的博客
02-16 273
序本文主要研究一下jvm的StringTable及SymbolTableStringTable及SymbolTableJDK的变动在java7的时候将字符串常量池移到java heap，字符串常量池被限制在整个应用的堆内存中，在运行时调用String.intern()增加字符串常量不会使永久代OOM了。使用-XX:StringTableSize可以设置StringTableSize，默认是6553...
JVM StringTable垃圾回收
qq_35677589的博客
03-31 174
StringTable使用的数据结构是hashtable这中数据结构是数组加链表。 StringTable是会被垃圾回收的 String Table调优： 1、调整StringTable的桶个数大小，当桶个数的大小越大的时候，StringTable装入相同的数量的String的对象的时间越短。注意hashTable最小值必须大于等于1009。 2、在程序运行的过程中，如果边操作边执行入池，那么内存那么会减少占用，提高计算机运算的效力 ...
10.JVM-StringTable/StringPool
Android系统优化
09-28 3269
String的基本特性、String的内存分配、String的基本操作、字符串拼接操作、intern()的使用、new String("ab")会创建几个对象、new String("a") + new String("b") 会创建几个对象、G1中的String去重操作
StringTable.pdf
03-11
《深入理解JVM中的StringTable》 在Java虚拟机（JVM）中，StringTable扮演着至关重要的角色，它是字符串常量池的实现，存放着程序中所有的字符串字面量。本文将详细探讨StringTable的原理、特点以及相关优化策略。 ...
StringTable.xmind
08-31
自己总结的jvm中StringTable的笔记，绘制了详细的思维导图，每个思维导图中均有详细的博文解释，方便大家学习和理解，免费分享给大家。适合jvm的爱好者和学习者
13_StringTable.pptx
05-21
StringTable
JVM系列之String.intern的性能解析
08-19
在Java虚拟机（JVM）中，`String.intern()` 是一个非常特殊且重要的方法，它与字符串常量池紧密相关。字符串常量池是一种内存优化机制，存储了程序中所有的字符串字面值和通过 `intern()` 方法添加的字符串。这个池...
JVM入门总结 .pdf
09-28
1. StringTable：JVM中的常量池用于存储编译期生成的各种字面量和符号引用，运行期转换为直接引用。其中的字符串常量在第一次使用时才变为真正的对象实例。JDK 1.8版本中，字符串拼接原理是通过StringBuilder实现，...
C\C++ Sqlite3使用详解
啊渊的专栏
08-21 252
在C++中使用SQLite创建表，你首先需要确保你的项目中已经包含了SQLite的库。SQLite是一个轻量级的数据库，它不需要一个独立的服务器进程或操作，并且完全嵌入到使用它的应用程序中。：SQLite的默认编译模式（在大多数系统上）是线程安全的，但如果你打算在多线程环境中使用SQLite，请确保你了解并遵守SQLite的线程安全规则。请记住，执行删除操作时要格外小心，因为一旦执行，被删除的数据就无法恢复了（除非你有备份）。：示例中包含了基本的错误处理，但在实际应用中你可能需要更详细的错误处理逻辑。
G1处理器GC调优常用参数详解
最新发布
m0_49200907的博客
08-21 776
G1 垃圾收集器会根据新生代空间不足、老年代占用空间超过阈值，以及达到 Mixed GC 周期等情况，来触发 Mixed GC。Mixed GC 是一种增量式的垃圾收集策略，可以有效地回收整个堆内存中的垃圾，并控制垃圾收集的停顿时间。
线程面试题
weixin_52449894的博客
08-19 371
先使用核心线程执行任务。当核心线程不足时，新任务入队列等待。当队列满且线程数未达最大值时，增加非核心线程执行任务。当队列满且线程数已达最大值时，触发拒绝策略处理新来的任务。长工 排队人数 短工。
【jvm】PC寄存器为什么设定为线程私有?
王佑辉的博客
08-20 459
如果PC寄存器不是线程私有的，那么为了保证线程之间的同步和互斥，就需要引入额外的同步机制（如锁）。通过将PC寄存器设定为线程私有，可以确保每个线程的执行状态不会被其他线程所干扰，从而保持并发执行的稳定性和可控性。：由于每个线程都有自己的PC寄存器，CPU在切换线程时只需要简单地读取和保存PC寄存器的值，就可以快速地恢复线程的执行状态，从而提高线程切换的效率。：如果多个线程共享同一个PC寄存器，那么当线程切换时，后一个线程的执行状态可能会覆盖前一个线程的执行状态，导致线程执行混乱。
【JVM】JVM解析字节码文件过程(一)
Cover_sky的博客
08-21 369
大端模式:高位存在低地址，低位存高地址小段模式：与大端模式相反。
jvm StringTable
07-25
JVM的StringTable是用于存储字符串常量的数据结构。在JVM中，字符串常量是指在代码中直接使用双引号括起来的字符串。 StringTable是一个哈希表，用于实现字符串常量的唯一性。它的作用是避免在内存中重复存储相同的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值