简介
String 对象有个特殊的 StringTable 字符串常量池，为了减少 Heap 中生成的字符串的数量，推荐尽量直接使用 String Table 中的字符串常量池中的元素。
那么 String.intern 的性能怎么样呢？我们一起来看一下。
String.intern 和 G1 字符串去重的区别
之前我们提到了，String.intern 方法会返回字符串常量池中的字符串对象的引用。
而 G1 垃圾回收器的字符串去重的功能其实和 String.intern 有点不一样，G1 是让两个字符串的底层指向同一个 byte[]数组。
有图为证：
上图中的 String1 和 String2 指向的是同一个 byte[]数组。
String.intern 的性能
我们看下 intern 方法的定义：
public native String intern();
复制代码
大家可以看到这是一个 native 的方法。native 底层肯定是 C++实现的。
那么是不是 native 方法一定会比 java 方法快呢？
其实 native 方法有这样几个耗时点：
native 方法需要调用 JDK-JVM 接口，实际上是会浪费时间的。
性能会受到 native 方法中 HashTable 实现方法的制约，如果在高并发的情况下，native 的 HashTable 的实现可能成为性能的制约因素。
举个例子
还是用 JMH 工具来进行性能分析，我们使用 String.intern，HashMap，和 ConcurrentHashMap 来对比分析，分别调用 1 次，100 次，10000 次和 1000000。
代码如下：
@State(Scope.Benchmark)@BenchmarkMode(Mode.AverageTime)@OutputTimeUnit(TimeUnit.NANOSECONDS)@Fork(value = 1, jvmArgsPrepend = "-XX:+PrintStringTableStatistics")@Warmup(iterations = 5)@Measurement(iterations = 5)public class StringInternBenchMark {
@Param({"1", "100", "10000", "1000000"}) private int size;
private StringInterner str; private ConcurrentHashMapInterner chm; private HashMapInterner hm;
@Setup public void setup() { str = new StringInterner(); chm = new ConcurrentHashMapInterner(); hm = new HashMapInterner(); }
public static class StringInterner { public String intern(String s) { return s.intern(); } }
@Benchmark public void useIntern(Blackhole bh) { for (int c = 0; c < size; c++) { bh.consume(str.intern("doit" + c)); } }
public static class ConcurrentHashMapInterner { private final Map<String, String> map;
public ConcurrentHashMapInterner() { map = new ConcurrentHashMap<>(); }
public String intern(String s) { String exist = map.putIfAbsent(s, s); return (exist == null) ? s : exist; } }
@Benchmark public void useCurrentHashMap(Blackhole bh) { for (int c = 0; c < size; c++) { bh.consume(chm.intern("doit" + c)); } }
public static class HashMapInterner { private final Map<String, String> map;
public HashMapInterner() { map = new HashMap<>(); }
public String intern(String s) { String exist = map.putIfAbsent(s, s); return (exist == null) ? s : exist; } }
@Benchmark public void useHashMap(Blackhole bh) { for (int c = 0; c < size; c++) { bh.consume(hm.intern("doit" + c)); } }
public static void main(String[] args) throws RunnerException { Options opt = new OptionsBuilder() .include(StringInternBenchMark.class.getSimpleName()) .build(); new Runner(opt).run(); }}
复制代码
输出结果：
Benchmark (size) Mode Cnt Score Error UnitsStringInternBenchMark.useCurrentHashMap 1 avgt 5 34.259 ± 7.191 ns/opStringInternBenchMark.useCurrentHashMap 100 avgt 5 3623.834 ± 499.806 ns/opStringInternBenchMark.useCurrentHashMap 10000 avgt 5 421010.654 ± 53760.218 ns/opStringInternBenchMark.useCurrentHashMap 1000000 avgt 5 88403817.753 ± 12719402.380 ns/opStringInternBenchMark.useHashMap 1 avgt 5 36.927 ± 6.751 ns/opStringInternBenchMark.useHashMap 100 avgt 5 3329.498 ± 595.923 ns/opStringInternBenchMark.useHashMap 10000 avgt 5 417959.200 ± 62853.828 ns/opStringInternBenchMark.useHashMap 1000000 avgt 5 79347127.709 ± 9378196.176 ns/opStringInternBenchMark.useIntern 1 avgt 5 161.598 ± 9.128 ns/opStringInternBenchMark.useIntern 100 avgt 5 17211.037 ± 188.929 ns/opStringInternBenchMark.useIntern 10000 avgt 5 1934203.794 ± 272954.183 ns/opStringInternBenchMark.useIntern 1000000 avgt 5 418729928.200 ± 86876278.365 ns/op
复制代码
从结果我们可以看到，intern 要比其他的两个要慢。
所以 native 方法不一定快。intern 的用处不是在于速度，而是在于节约 Heap 中的内存使用。
本文作者：flydean 程序那些事
本文链接：http://www.flydean.com/jvm-string-intern-performance/
本文来源：flydean 的博客
欢迎关注我的公众号:程序那些事，更多精彩等着您！
评论