关于java:JVM系列之Stringintern的性能

5次阅读

共计 3143 个字符，预计需要花费 8 分钟才能阅读完成。

String 对象有个非凡的 StringTable 字符串常量池，为了缩小 Heap 中生成的字符串的数量，举荐尽量间接应用 String Table 中的字符串常量池中的元素。

那么 String.intern 的性能怎么样呢？咱们一起来看一下。

之前咱们提到了，String.intern 办法会返回字符串常量池中的字符串对象的援用。

而 G1 垃圾回收器的字符串去重的性能其实和 String.intern 有点不一样，G1 是让两个字符串的底层指向同一个 byte[] 数组。

有图为证：

上图中的 String1 和 String2 指向的是同一个 byte[] 数组。

咱们看下 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 中的内存应用。