JVM系列之:String.intern的效能
阿新 • • 發佈：2020-07-28
[toc]
# 簡介
String物件有個特殊的StringTable字串常量池，為了減少Heap中生成的字串的數量，推薦儘量直接使用String Table中的字串常量池中的元素。
那麼String.intern的效能怎麼樣呢？我們一起來看一下。
# String.intern和G1字串去重的區別
之前我們提到了，String.intern方法會返回字串常量池中的字串物件的引用。
而G1垃圾回收器的字串去重的功能其實和String.intern有點不一樣，G1是讓兩個字串的底層指向同一個byte[]陣列。
有圖為證：
上圖中的String1和String2指向的是同一個byte[]陣列。
# String.intern的效能
我們看下intern方法的定義：
~~~java
public native String intern();
~~~
大家可以看到這是一個native的方法。native底層肯定是C++實現的。
那麼是不是native方法一定會比java方法快呢？
其實native方法有這樣幾個耗時點：
1. native方法需要呼叫JDK-JVM介面，實際上是會浪費時間的。
2. 效能會受到native方法中HashTable實現方法的制約，如果在高併發的情況下，native的HashTable的實現可能成為效能的制約因素。
# 舉個例子
還是用JMH工具來進行效能分析，我們使用String.intern，HashMap，和ConcurrentHashMap來對比分析，分別呼叫1次，100次，10000次和1000000。
程式碼如下：
~~~java
@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 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 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();
}
}
~~~
輸出結果：
~~~java
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中的記憶體使用。
>