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)
