JVM学习笔记Ⅵ

已于 2022-11-29 23:15:57 修改
阅读量170 收藏
点赞数
分类专栏： JVM专栏 文章标签： jvm 学习 java
于 2022-11-29 23:13:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MeiMing_104/article/details/128065823
版权

文章目录

13 StringTable

String的基本特性

  • String: 字符串，使用一对""引起来表示。
    • String s1 = “ming”; //字面量的定义方式
    • String s2 = new String(“ming”);
  • String声明为final的，不可被继承
  • String实现了Serializable接口：表示字符串是支持序列化的。
    实现了Comparable接口：表示String可以比较大小。
  • String在jdk1.8及以前内部定义了final char[] value用于存储字符串数据。在jdk9时改为了byte[]。

为什么要修改为byte？
动机：因为大部分在堆中的String是 Latin-1 字符，用1个字节就能存储，那么意味着还有1个字节就被
浪费了。
所以改为byte后，如果存储ISO-8859-1/Latin-1的话，用1个字节就行，如果是汉字的话，额外加上一个字节就行。
结论：在1.9中，String再也不用char[] 来存储了，改成了byte[]加上编码标记，节约了一些空间。当然在StringBuffer和StringBuilder中也做了相应的修改。

  • String：代表不可变的字符序列，简称：不可变性。

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

  • 通过字面的方式(区别于new)给一个字符串赋值，此时的字符串值声明在字符串常量池中。

public class StringTest1 {
    @Test
    public void test1(){
        String s1="abc"; //字面量定义方式, "abc"存储在堆中字符串常量池中
        String s2="abc";
        System.out.println(s1==s2);  //判断地址：true
        s1="hello";
        System.out.println(s1==s2);  //判断地址： false
        System.out.println(s1);  // hello
        System.out.println(s2);  // abc
    }

    @Test
    public void test2(){
        String s1="abc";
        String s2="abc";
        System.out.println(s1==s2);  //判断地址：true
        s1+="def";
        System.out.println(s1==s2);  //判断地址： false
        System.out.println(s1);  // abcdef
        System.out.println(s2);  // abc
    }

    @Test
    public void test3(){
        String s1="abc";
        String s2=s1.replace('a','m');

        System.out.println(s1==s2);  //判断地址： false
        System.out.println(s1);  // abc
        System.out.println(s2);  // mbc
    }
}


// 面试题
public class StringExer {
    String str =new String("abc");
    char[] ch = {'t','e','s','t'};
    public void change(String str,char ch[]){
        str="test ok";
        ch[0]='b';
    }

    public static void main(String[] args) {
        StringExer ex = new StringExer();
        ex.change(ex.str,ex.ch);
        System.out.println(ex.str);  // abc
        System.out.println(ex.ch);  // best
    }
}

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

  • String的String Pool是一个固定大小的Hashtable，默认值大小是1009。如果放进String Pool的String非常多，就会造成Hash冲突严重，从而导致链表会很长，而链表长了后，直接会造成的影响就是当调用String.intern时性能会大幅下降。
  • 使用 -XX:StringTableSize可设置StringTable的长度
  • 在jdk1.6中StringTable是固定的，就是1009的长度，所以如果常量池中的字符串过多就会导致效率下降很快。StringTableSize设置没有要求
  • 在jdk1.7中，StringTable的默认长度是60013，StringTableSize设置没有要求。
  • 在jdk1.8中，StringTable的默认长度是60013，StringTableSize设置有要求：最小值为1009。
/**
 * @Author: mei_ming
 * @DateTime: 2022/11/27 17:52
 * @Description: 测试
 *
 * 测试JDK1.8中，StringTable的默认大小与下限：
 * (-XX:StringTableSize=1000)
 * ① jps
 * ② jinfo -flag StringTableSize 进程号
 * 
 * 默认大小：60013
 * 下限：1009
 *
 * Error: Could not create the Java Virtual Machine.
 * Error: A fatal exception has occurred. Program will exit.
 * StringTable size of 1000 is invalid; must be between 1009 and 2305843009213693951
 */
public class StringTest2 {
    public static void main(String[] args) {
        System.out.println("我是来打酱油的！");
        try {
            Thread.sleep(1000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/**
 * @Author: mei_ming
 * @DateTime: 2022/11/27 22:11
 * @Description: 探究StringTable的大小对读取效率的影响
 * 1. -XX:StringTableSize=1009
 * 2. -XX:StringTableSize=100009
 */
public class StringTest3 {
    public static void main(String[] args) {
        BufferedReader br = null;

        try {
            br=new BufferedReader(new FileReader("words.txt"));
            long start = System.currentTimeMillis();
            String data;
            while((data=br.readLine())!=null){
                data.intern();  //如果在字符串常量池中没有对应data的字符串的话，则在常量池中生成
            }
            long end =System.currentTimeMillis();
            System.out.println("花费时间为: "+(end-start));
            // 1009 : 338ms
            // 100009 : 132ms
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

String的内存分配

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

  • 常量池就类似一个Java系统级别提供的缓存。8种基本数据类型的常量池都是系统协调的，String类型的常量池比较特殊。它的主要是由方法有两种。

    • 直接使用双引号声明出来的String对象会直接存储在常量池中。String s1 = "abc";
    • 如果不是双引号声明的，还可以使用String提供的intern()方法。

  • Java 6 及以前，字符串常量池存放在永久代。(永久代默认比较小)

  • Java 7中Oracle 的工程师对字符串池的逻辑做了很大的改变，即将字符串常量池的位置调整到Java堆内。

    • 所有的字符串都保存在堆(Heap)中，和其它普通对象一样，这样可以让你在进行调优应用时，仅需要调整堆大小就可以了。
    • 字符串常量池概念原来使用得比较多，但是这个改动使得我们有足够得理由让我们重新考虑在Java 7中使用String.intern().

  • Java 8 元空间，字符串常量池在还在堆中

为什么StringTable要调整？

  1. permSize默认比较小，较少使用intern方法。
  2. 永久代垃圾回收频率低，+ 比较小，更容易报OOM
/**
 * @Author: mei_ming
 * @DateTime: 2022/11/28 20:04
 * @Description: OOM验证
 * jdk6中：
 * -XX:PerSize=6m -XX:MaxPermSize=6m -Xms6m -Xmx6m
 *
 * jdk8中：
 * -XX:MetaspaceSize=10m -XX:MaxMetaspaceSize=10m -Xms6m -Xmx6m
 *
 * OutOfMemoryError: Java heap space
 *
 */
public class StringTest4 {
    public static void main(String[] args) {
        //使用Set保持着常量池引用，避免full gc 回收常量池行为
        Set<String> set = new HashSet<String>();

        //在short 可以取值得范围内足以让6MB得PermSize或heap产生OOM
        short i=0;
        while(true){
            set.add(String.valueOf(i++).intern());
        }
    }
}

String的基本操作

案例1：

package com.ming.java1;

/**
 * @Author: mei_ming
 * @DateTime: 2022/11/28 20:20
 * @Description: 证明常量池中不存在相同的元素
 * Debug 看右侧 Memory 中 java.lang.String 的个数
 */
public class StringTest5 {
    public static void main(String[] args) {
        System.out.println();  // 2224
        System.out.println("1");  // 2225
        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");  // 2234
		//如下的1-10 不会生成对应的常量
        System.out.println("1");  // 2235
        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");  // 2235
    }
}

如上代码所示：Java语言规范里，要求完全相同的字符串字面量，应该包含同样的Unicode字符序列（包含同一份码点序列的常量），并且必须是指向同一个String类实例。

案例2：

public class Memory {
    public static void main(String[] args) {
        int i = 1;
        Object obj = new Object();
        Memory mem = new Memory();
        mem.foo(obj);
    }

    private void foo(Object obj) {
    	//在非static方法中，局部变量表第0位默认是this
        String str = obj.toString();
        System.out.println(str);
    }
}

内存图

字符串拼接操作

结论：

  1. 常量与常量的拼接结果在常量池，原理是编译器优化
  2. 常量池中不会存在相同内容的常量
  3. 只要其中一个是变量，结果就在堆中，变量拼接的原理是StringBuilder
  4. 如果拼接的结果调用intern()方法，则主动将常量池中还没有的字符串对象放入池中，并返回此对象地址

代码说明：

package com.ming.java1;

import org.junit.Test;

/**
 * @Author: mei_ming
 * @DateTime: 2022/11/28 20:42
 * @Description: 字符串拼接操作
 */
public class StringTest6 {

    @Test
    public void test() {
        String s1 = "a" + "b" + "c";  //编译期优化,字符串常量池中 "abc"
        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
    }

    @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，并返回对象地址
        String s8 = s6.intern();
        System.out.println(s3 == s8);  // true
    }

    @Test
    public void test3() {
        String s1 = "a";
        String s2 = "b";
        String s3 = "ab";
        String s4 = s1 + s2;
        System.out.println(s3 == s4);  // false
        /**
         *  0 ldc #14 <a>
         *  2 astore_1
         *  3 ldc #15 <b>
         *  5 astore_2
         *  6 ldc #16 <ab>
         *  8 astore_3
         *  9 new #9 <java/lang/StringBuilder>
         * 12 dup
         * 13 invokespecial #10 <java/lang/StringBuilder.<init> : ()V>
         * 16 aload_1
         * 17 invokevirtual #11 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
         * 20 aload_2
         * 21 invokevirtual #11 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
         * 24 invokevirtual #12 <java/lang/StringBuilder.toString : ()Ljava/lang/String;>
         * 27 astore 4
         * 29 getstatic #3 <java/lang/System.out : Ljava/io/PrintStream;>
         * 32 aload_3
         * 33 aload 4
         * 35 if_acmpne 42 (+7)
         * 38 iconst_1
         * 39 goto 43 (+4)
         * 42 iconst_0
         * 43 invokevirtual #4 <java/io/PrintStream.println : (Z)V>
         * 46 return
         *
         * 说明： s4 = s1 + s2 的执行细节 （变量s是我们定义的）
         * ①：StringBuilder s = new StringBuilder();
         * ②：s.append("a");
         * ③：s.append("b");
         * ④：s.toString()  --> 约等于 new String("ab")
         *
         * 补充：在jdk5.0之后使用的是StringBuilder，
         *      在jdk5.0之前使用的是StringBuffer。
         */
    }

    /**
     * 1. 字符串拼接操作不一定使用的是StringBuilder！
     * 如果拼接符号左右两边都是字符串常量或常量引用，则仍然使用编译期优化，
     * 2. 针对于final修饰类、方法、基本数据，引用类型的量的结构时，能使用上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";
        String s5 = s4+"hadoop";
        System.out.println(s1 == s5);  //true
    }

    /**
     * 对比效率:通过StringBuilder的append()的方式添加字符串的效率要远高于使用String的字符串拼接方式
     * 详情: 1. StringBuilder的方式:自始至终只创建一个StringBuilder对象
     *          而String拼接的方式:创建了多个StringBuilder和String对象
     *      2. 使用String的字符串拼接方式:内存中由于创建了较多的StringBuilder和String对象,内存占用大,如果要GC,也要花费时间
     *
     *  改进: 如果基本确定大小时,使用带参构造器指定大小,节省扩容的时间
     */

    @Test
    public void test6() {
        long start =System.currentTimeMillis();
        method1(100000);  // 10837ms
//        method2(100000);  // 5ms
        long end = System.currentTimeMillis();

        System.out.println("take time: "+(end-start));
    }

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

    private void method2(int highLevel) {
        //只需要创建一个StringBuilder
        StringBuilder src = new StringBuilder();
        for (int i = 0; i <highLevel ; i++) {
            src.append("a");
        }
    }

}

intern()的使用

如果不是用双引号声明的String对象，可以使用String提供的intern方法：intern方法会从字符串常量池中查询当前字符串是否存在，若不存在就会将当前字符串放入常量池中。

  • 比如： String str = new String("mem").intern()

也就是说，如果在任意字符串上调用String.intern()方法，那么其返回结果所指向的哪个类实例，必须和直接以常量形式出现的字符串实例完全相同。因此，下列表达式的值必定为true：
("a"+"b"+"c").intern() == "abc"
通俗点讲，Interned String就是确保字符串在内存里只有一份拷贝，这样可以节约内存空间，加快字符串操作任务的执行速度。注意，这个值会被存放在字符串常量池中。

问：如何保证变量s指向的是字符串常量池中的数据?
答：有两种方式：

  1. String s =“mem”; //字面量定义的方式
  2. 使用intern(),即 String s = new String(“mem”).intern()

题目1：new String(“ab”) 会创建几个对象？
拓展：new String(“a”)+new String(“b”)呢？
代码说明：

package com.ming.java2;

/**
 * @Author: mei_ming
 * @DateTime: 2022/11/29 20:42
 * @Description:
 * 题目1：new String("ab")会创建几个对象？看字节码就知道是2个
 *   说明： 一个对象是：new关键字在 堆空间 创建的
 *         另一个对象是： 字符串常量池 中的对象"ab"，字节码指令：ldc
 *
 * 题目2：new String("a")+new String("b")呢？
 *  对象1： 拼接, new关键字 生成StringBuilder对象
 *  对象2：new String("a")时，在堆中生成String对象
 *  对象3：new String("a")时，在字符串常量池 中生成 "a" , ldc
 *  对象4：new String("b")时，在堆中生成String对象
 *  对象5：new String("b")时，在字符串常量池 中生成 "b" , ldc
 *  
 *  深度刨析： 在最后调用StringBuilder的toString()方法中
 *  对象6：new String("ab") 在堆中生成的String对象
 *      强调一下，toString() 方法的调用，并不会在常量池中生成 "ab",没有ldc指令
 */
public class StringNewTest {
    public static void main(String[] args) {
//        String str = new String("ab");
        /**
         * new String("ab")的指令
         *  0 new #2 <java/lang/String>  --> 第一个
         *  3 dup
         *  4 ldc #3 <ab>   -->第二个
         *  6 invokespecial #4 <java/lang/String.<init> : (Ljava/lang/String;)V>
         *  9 astore_1
         * 10 return 
         */
        String str = new String("a")+new String("b");
        /**
         * new String("a")+new String("b")的指令
         *    0 new #2 <java/lang/StringBuilder>
         *    3 dup
         *    4 invokespecial #3 <java/lang/StringBuilder.<init> : ()V>
         *    7 new #4 <java/lang/String>
         *   10 dup
         *   11 ldc #5 <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>
         *   22 dup
         *   23 ldc #8 <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;>
         *   34 astore_1
         *   35 return
         * 
         * toString()的指令:    
         *    0 new #80 <java/lang/String>
         *    3 dup
         *    4 aload_0
         *    5 getfield #234 <java/lang/StringBuilder.value : [C>
         *    8 iconst_0
         *    9 aload_0
         *   10 getfield #233 <java/lang/StringBuilder.count : I>
         *   13 invokespecial #291 <java/lang/String.<init> : ([CII)V>
         *   16 areturn
         */
    }
}

面试题：

public class StringIntern {
    public static void main(String[] args) {
        String s = new String("1");  //生成了一个对象在堆，一个"1"在常量池，堆中的引用给s
        s.intern();  //在调用此方法之前，字符串常量池中已经有"1"
        String s2 = "1";  //将"1"的引用给s2
        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"
        String s4 = "11";  // 把常量池的"11"引用赋给 s4
        System.out.println(s3 == s4);
        // jdk6： false   jdk7/8： true
        /**
         * 解释；在调用s3.intern()方法时
         * jdk6：在常量池中，创建了一个新的对象"11",也就有新的地址了，
         *       此时s3记录的是堆空间的地址，s4记录的是常量池中的地址
         * 但：
         * jdk7/8：在调用s3.intern()方法时，会在常量池中引用s3堆空间的地址，
         *       此时s4就引用s3中堆空间的地址，所以一致。(这样做的好处：为了节约空间，直接取引用)
         *
         * 触发条件： 在new String()时没有在常量池中生成对应字符串，而是通过intern()方法引用，
         *          此时常量池中的值才会是 new String()时，在堆中的地址。
         */
    }
}

在JDK6中，内存图示：
jdk6
在JDK7/8中，内存图示：
jdk7/8
对new String()+new String() 难度升级：

public class StringIntern1 {
    public static void main(String[] args) {
        String s3 = new String("1") + new String("1");
        // 执行完上一行代码以后，字符串常量池中并不会生成"11"
        String s4 = "11";  //在字符串常量池中生成的"11"
        String s5 = s3.intern();
        System.out.println(s3 == s4);  // false  s3 为堆中的地址，s4为常量池中的地址
        System.out.println(s5 == s4);  // true   s5 为常量池中已有"11"的引用，s4为常量池中的地址
    }
}

总结String的intern()的使用：

  • jdk1.6中，将这个字符串对象尝试放入串池。
    • 如果串池中有，则并不会放入，返回已有的串池中的对象的地址
    • 如果没有，会把此对象复制一份，放入串池，并返回串池中对象的地址。
  • jdk1.7起，将这个字符串对象尝试放入串池。
    • 如果串池中有，则并不会放入，返回已有的串池中的对象的地址
    • 如果没有，会把此对象的引用地址复制一份，放入串池，并返回串池中对象的引用地址。

练习1：

public class StringExer1 {
    public static void main(String[] args) {
    	//String x = "ab";
        String s = new String("a")+new String("b");
        // 执行完上一行代码以后，字符串常量池中并不会生成"ab"
        String s2 = s.intern();  //jdk6:在串池中创建一个字符串 "ab"
                                    //jdk8: 串池中没有创建"ab",而是创建一个引用，指向new String("ab"),将此引用返回。
        System.out.println(s2 == "ab");  //jdk6：true  jdk7/8：true
        System.out.println(s == "ab");  //jdk6：false  jdk7/8：true
    }
}

内存分析：
6
7/8
新
练习2：

public class StringExer2 {
    public static void main(String[] args) {
//        String s1 = new String("ab");  //字符串常量池中 会生成"ab"
        String s1 = new String("a")+new String("b");  //字符串常量池中并 不会生成"ab"
        s1.intern();

        String s2= "ab";
        System.out.println(s1 == s2);
    }
}

intern()的效率测试：

/**
 * @Author: mei_ming
 * @DateTime: 2022/11/29 22:32
 * @Description: 空间效率测试：
 */
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("take time: "+(end-start)); // 9334  intern(): 3016

        try {
            Thread.sleep(100000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

1
2

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

StringTable的垃圾回收

/**
 * @Author: mei_ming
 * @DateTime: 2022/11/29 22:59
 * @Description: 测试垃圾回收
 *
 * -Xms15m -Xmx15m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails
 * 回收的是堆中的数据
 */
public class StringGCTest {
    public static void main(String[] args) {
        for (int i = 0; i < 100000; i++) {
            String.valueOf(i).intern();
        }
    }
}

G1中的String去重操作

注意这里说的重复，指的是在堆中的数据，而不是常量池中的，因为常量池中的本身就不会重复

JEP 192: String Deduplication in G1

描述

  • 背景：对许多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对象被认为是去重的候选对象
MeiMing_104
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马JVM学习笔记二
01-20
title: 黑马JVM学习笔记二 date: 2020-01-13 1:00:00 tags: JVM categories: JVM 黑马jvm 内存结构 内存结构总览图： 程序计数器 1.定义：Program Counter Register 程序计数器 (寄存器) 程序计数器是Java对物理...
JDK1.8 Java新特性总结
m0_70808444的博客
08-25 998
一个接口中只有一个抽象方法,这种接口称为函数式接口;
使用jdk8的Stream来获取数组最小值、最大值、总和、平均数
m0_63526467的博客
04-04 3662
1. 求数组的总和 static int [] intArr = new int[]{30,96,23,69,85,62,12,99,11}; public static void main(String[] args) { IntStream intStream =Arrays.stream(intArr); int sum = intStream.sum(); System.out.println("总和："+sum); }
jdk1.8——Stream
FlyLikeButterfly的博客
01-10 594
jdk1.8的Stream
stream流详解(JDK1.8的特性)
卷NM呢！不干了！
06-10 4884
Stream流 一 : Stream流的介绍 二 : 获取Stream流的方式 三 : Stream流中的常用方法 1.forEach（终结方法） 2.过滤：filter 3.映射(转换)：map 4.统计个数：count（终结方法） 5.取用前几个（截取）：limit 6.跳过前几个元素：skip 7.组合（合并流）：concat 8.筛选：distinct 9.映射(打开后再转换)：flatMap 10.自然排序：sorted 11.定制排序：sorted(Comparator com) 12.检测匹配
Java8用Stream流一行代码实现数据分组统计，排序，最大值、最小值、平均值、总数、合计
热门推荐
xiaoheihai666的博客
12-02 2万+
Java8对数据处理可谓十分流畅，既不改变数据，又能对数据进行很好的处理，今天给大家演示下，用Java8的Stream如何对数据进行分组统计，排序，求和等汇总统计方法找到汇总统计的方法。这些方法属于java 8的汇总统计类。getAverage(): 它返回所有接受值的平均值。getCount(): 它计算所有元素的总数。getMax(): 它返回最大值。getMin(): 它返回最小值。getSum(): 它返回所有元素的总和。看官可以根据自己的需求进行灵活变通。
JVM学习笔记
04-28
从JVM内存模型、常用JVM参数、垃圾回收算法和垃圾回收器等几个角度学习JVM
jvm学习笔记.zip
04-04
jvm经典笔记
JVM学习笔记(一)
06-02
一份JVM学习的笔记,含查看JVM运行时信息\JVM垃圾收集信息\JVM锁信息等
jVM学习笔记.ppt
11-20
jVM学习笔记.ppt
JDK1.8新特性总结 - 篇二(Stream API)
爱喝咖啡的程序员的博客
05-24 495
篇一中谈到了Lambda的基本语法，核心函数式接口以及方法引用的概念，现在让我们把关注点放到Stream Api上 一. Stream API 流是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列。集合关注的是数据，而流关注的是计算！ 注意: 1. Stream不会自己存储元素。 2. Str...
String数组的不变性
yz18931904的博客
01-31 114
public class StringExer { String str = new String("good"); char[] ch = {'t', 'e', 's', 't'}; public void change(String str, char ch[]) { str = "test ok"; ch[0] = 'b'; } public static void main(String[] args) { ..
String的特性
qq_45824565的博客
11-23 172
一.final final修饰变量：变量的地址不能被改变(不能被重新赋值）。 final修饰方法：该方法不能被重写。 final修饰类：该类不能被继承。 二.String为什么被设计为不可变的 String的源码： public final class String implements java.io.Serializable, Comparable<String>, CharSequence { /** The value is used for character .
java工程师面试常用考的175道题
蚂蚁
06-21 7211
本文由ziminhedao贡献     《Java程序设计》理论题库—选择题（单选175题）    1.欲构造ArrayList类的一个实例，此类继承了List接口，下列哪个方法是正确的？ B     A、 ArrayList myList=new Object（）；     B、 List myList=new ArrayList（）；     C、 ArrayList myLis
【深入理解Java虚拟机】内存与垃圾回收篇（下）
Java
07-23 223
【JVM】尚硅谷宋红康JVM系列1：内存与垃圾回收篇（下） 一、执行引擎 1.1 执行引擎概述 1.2 Java代码编译和执行过程 1.3 机器码、指令、汇编语言 1.4 解释器 1.5 JIT编译器 总结： 解释器采用逐行解释，启动快，但是把总体的字节码解释成本地代码的周期较长，需要一定的时间。 即时编译器，启动慢，因为启动后要先编译大量字节码变成本地代码，然后一气呵成的执行。 1.6 HotSpot设置模式：C1、C2编译器
Java中的JVM是什么？如何调优JVM的性能？
最新发布
2301_79405789的博客
06-15 319
JVM，即Java虚拟机，是一个能够执行Java字节码（.class文件）的抽象计算机。它作为Java代码与操作系统之间的中间层，使得Java程序能够实现“一次编写，到处运行”的理念。
JVM的几种常见垃圾回收算法
2201_75437633的博客
06-09 742
引言：Java Virtual Machine（JVM）作为Java程序运行的核心，其垃圾回收（Garbage Collection, GC）机制在内存管理中起着至关重要的作用。垃圾回收算法是JVM性能优化的重要方面。本文将详细介绍几种常见的垃圾回收算法，包括标记-清除（Mark-and-Sweep）、复制（Copying）、标记-整理（Mark-and-Compact）、分代收集（Generational Collection）和G1（Garbage-First）等。
C++中的堆和栈内存定义以及区别
2402_85246552的博客
06-15 327
栈的大小在程序编译时确定，通常是有限的（例如，在大多数系统中，栈的大小可能只有几兆字节）。：与栈内存相比，堆内存的访问速度较慢，因为系统需要维护一个复杂的内存管理结构来跟踪哪些内存块是可用的，哪些已经被分配了。综上所述，堆和栈在管理方式、申请方式、生长方向、空间大小、内存利用率、用途和错误处理等方面都存在明显的区别。与栈不同，堆的大小在程序运行时动态确定，并且由程序员负责分配和释放内存（使用。下，栈的大小是固定的（编译时确定），不适合在函数内申请过多的栈空间，否则可能导致程序栈溢出。
JVM产生FullGC的原因有哪些？
常备不懈
06-12 908
在Java虚拟机（JVM）中，垃圾回收（Garbage Collection，简称GC）是一个非常重要的机制。GC的目的是自动管理内存，回收不再使用的对象，防止内存泄漏。在JVM中，Full GC是一种比较昂贵的操作，它会暂停应用程序的执行（Stop-the-World），对所有的堆内存进行垃圾回收。因此，了解产生Full GC的原因，对于优化Java应用的性能至关重要。本文将详细探讨JVM产生Full GC的几种主要原因。
宋红康jvm学习笔记 逃逸分析
05-19
逃逸分析是JVM在运行时对对象的分析，用于确定对象的作用域。如果对象只在方法内部使用，那么它就不会逃逸出该方法，否则就会逃逸。逃逸分析可以优化程序的性能，因为当对象不逃逸时，JVM可以将它们放在线程栈上分配...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值