jvm之StringTable解读（三）-阿里云开发者社区

jvm之StringTable解读（三）

2023-07-25 80

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： jvm之StringTable解读（三）

intern的使用：JDK6 vs JDK7/8

1. 
2. /*
3.  * ① String s3 = new String("1") + new String("1")
4.  * 等价于new String（"11"），但是，常量池中并不生成字符串"11"；
5.  *
6.  * ② s3.intern()
7.  * 由于此时常量池中并无"11"，所以把s3中记录的对象的地址存入常量池
8.  * 所以s3 和 s4 指向的都是一个地址
9. */
10. String s3 = new String("1") + new String("1");
11. s3.intern();
12. String s4 = "11";
13. System.out.println(s3==s4); //jdk1.6 false jdk7/8 true

1. /**
2.  * ① String s = new String("1")
3.  * 创建了两个对象
4.  *     堆空间中一个new对象
5.  *     字符串常量池中一个字符串常量"1"（注意：此时字符串常量池中已有"1"）
6.  * ② s.intern()由于字符串常量池中已存在"1"
7.  * 
8.  * s  指向的是堆空间中的对象地址
9.  * s2 指向的是堆空间中常量池中"1"的地址
10.  * 所以不相等
11.  */
12. String s = new String("1");
13. s.intern();
14. String s2 = "1";
15. System.out.println(s==s2); // jdk1.6 false jdk7/8 false

JDK1.6中，将这个字符串对象尝试放入串池。

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

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

JDK1.7起，将这个字符串对象尝试放入串池。

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

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

StringBuilder中调用toString方法返回的字符串不会在常量池中放置。

Java中的常量池指的是存放字符串常量的一块内存区域，当创建一个字符串常量时，如果常量池中没有该常量，则会在常量池中创建该常量，并返回该常量在常量池中的引用。

如果常量池中已存在该常量，则直接返回该常量在常量池中的引用。而StringBuilder类是可变的字符串类，当调用其toString()方法时，会返回一个新字符串，该字符串不是从常量池中获取的，而是在堆中创建的一个新的字符串对象。

因为StringBuilder对象是可变的，每次操作都会改变其内部状态，所以不可能将该对象所表示的字符串放入常量池中，否则会破坏字符串常量的不可变性。 因此，StringBuilder中调用toString方法返回的字符串不会在常量池中放置。

intern的效率测试：空间角度

1. public class StringIntern2 {
2. static final int MAX_COUNT = 1000 * 10000;
3. static final String[] arr = new String[MAX_COUNT];
4. 
5. public static void main(String[] args) {
6.         Integer [] data = new Integer[]{1,2,3,4,5,6,7,8,9,10};
7. long start = System.currentTimeMillis();
8. for (int i = 0; i < MAX_COUNT; i++) {
9. // arr[i] = new String(String.valueOf(data[i%data.length]));
10.             arr[i] = new String(String.valueOf(data[i%data.length])).intern();
11.         }
12. long end = System.currentTimeMillis();
13.         System.out.println("花费的时间为：" + (end - start));
14. 
15. try {
16.             Thread.sleep(1000000);
17.         } catch (Exception e) {
18.             e.getStackTrace();
19.         }
20.     }
21. }
22. 
23. // 运行结果
24. 不使用intern：7256ms
25. 使用intern：1395ms

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

StringTable的垃圾回收

1. public class StringGCTest {
2. /**
3.      * -Xms15m -Xmx15m -XX:+PrintGCDetails
4.      */
5. public static void main(String[] args) {
6. 
7. for (int i = 0; i < 100000; i++) {
8.             String.valueOf(i).intern();
9.         }
10.     }
11. }

运行

1. [GC (Allocation Failure) [PSYoungGen: 4096K->504K(4608K)] 4096K->1689K(15872K), 0.0581583 secs] [Times: user=0.00 sys=0.00, real=0.06 secs] 
2. [GC (Allocation Failure) [PSYoungGen: 4600K->504K(4608K)] 5785K->2310K(15872K), 0.0015621 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
3. [GC (Allocation Failure) [PSYoungGen: 4600K->504K(4608K)] 6406K->2350K(15872K), 0.0034849 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
4. Heap
5.  PSYoungGen      total 4608K, used 1919K [0x00000000ffb00000, 0x0000000100000000, 0x0000000100000000)
6.   eden space 4096K, 34% used [0x00000000ffb00000,0x00000000ffc61d30,0x00000000fff00000)
7.   from space 512K, 98% used [0x00000000fff00000,0x00000000fff7e010,0x00000000fff80000)
8.   to   space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
9.  ParOldGen       total 11264K, used 1846K [0x00000000ff000000, 0x00000000ffb00000, 0x00000000ffb00000)
10.   object space 11264K, 16% used [0x00000000ff000000,0x00000000ff1cd9b0,0x00000000ffb00000)
11.  Metaspace       used 3378K, capacity 4496K, committed 4864K, reserved 1056768K
12. class space    used 361K, capacity 388K, committed 512K, reserved 1048576K

G1中的String去重操作

目前，许多大规模的Java应用程序在内存上遇到了瓶颈。测量表明，在这些类型的应用程序中，大约25%的Java堆实时数据集被String'对象所消耗。此外，这些 "String "对象中大约有一半是重复的，其中重复意味着 "string1.equals(string2) "是真的。在堆上有重复的String'对象，从本质上讲，只是一种内存的浪费。这个项目将在G1垃圾收集器中实现自动和持续的`String'重复数据删除，以避免浪费内存，减少内存占用。

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

背景：对许多Java应用（有大的也有小的）做的测试得出以下结果：

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

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

string对象的平均长度是45

许多大规模的Java应用的瓶颈在于内存，测试表明，在这些类型的应用里面，Java堆中存活的数据集合差不多25%是String对象。更进一步，这里面差不多一半string对象是重复的，重复的意思是说： stringl.equals(string2)= true。堆上存在重复的String对象必然是一种内存的浪费。这个项目将在G1垃圾收集器中实现自动持续对重复的string对象进行去重，这样就能避免浪费内存。

实现

当垃圾收集器工作的时候，会访问堆上存活的对象。对每一个访问的对象都会检查是否是候选的要去重的String对象

如果是，把这个对象的一个引用插入到队列中等待后续的处理。一个去重的线程在后台运行，处理这个队列。处理队列的一个元素意味着从队列删除这个元素，然后尝试去重它引用的string对象。

使用一个hashtable来记录所有的被String对象使用的不重复的char数组。当去重的时候，会查这个hashtable，来看堆上是否已经存在一个一模一样的char数组。

如果存在，String对象会被调整引用那个数组，释放对原来的数组的引用，最终会被垃圾收集器回收掉。

如果查找失败，char数组会被插入到hashtable，这样以后的时候就可以共享这个数组了。

1. # 开启String去重，默认是不开启的，需要手动开启。 
2. UseStringDeduplication(bool)  
3. # 打印详细的去重统计信息 
4. PrintStringDeduplicationStatistics(bool)  
5. # 达到这个年龄的String对象被认为是去重的候选对象
6. StringpeDuplicationAgeThreshold(uintx)