共计 3143 个字符,预计需要花费 8 分钟才能阅读完成。
简介
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 Units
StringInternBenchMark.useCurrentHashMap 1 avgt 5 34.259 ± 7.191 ns/op
StringInternBenchMark.useCurrentHashMap 100 avgt 5 3623.834 ± 499.806 ns/op
StringInternBenchMark.useCurrentHashMap 10000 avgt 5 421010.654 ± 53760.218 ns/op
StringInternBenchMark.useCurrentHashMap 1000000 avgt 5 88403817.753 ± 12719402.380 ns/op
StringInternBenchMark.useHashMap 1 avgt 5 36.927 ± 6.751 ns/op
StringInternBenchMark.useHashMap 100 avgt 5 3329.498 ± 595.923 ns/op
StringInternBenchMark.useHashMap 10000 avgt 5 417959.200 ± 62853.828 ns/op
StringInternBenchMark.useHashMap 1000000 avgt 5 79347127.709 ± 9378196.176 ns/op
StringInternBenchMark.useIntern 1 avgt 5 161.598 ± 9.128 ns/op
StringInternBenchMark.useIntern 100 avgt 5 17211.037 ± 188.929 ns/op
StringInternBenchMark.useIntern 10000 avgt 5 1934203.794 ± 272954.183 ns/op
StringInternBenchMark.useIntern 1000000 avgt 5 418729928.200 ± 86876278.365 ns/op
从后果咱们能够看到,intern 要比其余的两个要慢。
所以 native 办法不肯定快。intern 的用途不是在于速度,而是在于节约 Heap 中的内存应用。
本文作者:flydean 程序那些事
本文链接:http://www.flydean.com/jvm-string-intern-performance/
本文起源:flydean 的博客
欢送关注我的公众号: 程序那些事,更多精彩等着您!