JVM中String.intern方法如何影响不同场景下的性能表现？
- 内容介绍
- 文章标签
- 相关推荐
本文共计1012个文字，预计阅读时间需要5分钟。
String对象拥有一个特殊的StringTable字符字符串常量池，为了减少Heap中生成的字符串数量，推荐尽可能直接使用String+Table中字符串常量池中的元素。那么String.intern()的性能如何呢？
String.intern()的性能通常很好，因为它利用了StringTable来存储已经存在的字符串实例，避免了重复创建相同的字符串对象。以下是String.intern()的一些特点：
1. 高效性：由于StringTable是静态的，并且通常在JVM启动时就被初始化，因此intern()操作非常快速。
2. 节省内存：通过重用已经存在的字符串实例，可以减少内存的消耗。
3. 线程安全：String.intern()是线程安全的，可以在多线程环境中安全使用。
4. 可预测性：对于相同的字符串，无论何时调用intern()，返回的引用都是相同的。
然而，也有一些注意事项：
- 初始化开销：StringTable在JVM启动时初始化，这个过程可能会有一定的开销。
- 性能影响：对于大量使用intern()的场景，如果StringTable中已经存在对应的字符串，那么性能不会有太大影响；但如果字符串池中不存在对应的字符串，则需要将字符串添加到池中，这个过程可能会有些性能开销。
总的来说，String.intern()是一个非常有用的方法，特别是在需要重用字符串的场景中。
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中的内存使用。
到此这篇关于JVM系列之String.intern的性能解析的文章就介绍到这了,更多相关String.intern的性能内容请搜索自由互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持自由互联！
本文共计1012个文字，预计阅读时间需要5分钟。
String对象拥有一个特殊的StringTable字符字符串常量池，为了减少Heap中生成的字符串数量，推荐尽可能直接使用String+Table中字符串常量池中的元素。那么String.intern()的性能如何呢？
String.intern()的性能通常很好，因为它利用了StringTable来存储已经存在的字符串实例，避免了重复创建相同的字符串对象。以下是String.intern()的一些特点：
1. 高效性：由于StringTable是静态的，并且通常在JVM启动时就被初始化，因此intern()操作非常快速。
2. 节省内存：通过重用已经存在的字符串实例，可以减少内存的消耗。
3. 线程安全：String.intern()是线程安全的，可以在多线程环境中安全使用。
4. 可预测性：对于相同的字符串，无论何时调用intern()，返回的引用都是相同的。
然而，也有一些注意事项：
- 初始化开销：StringTable在JVM启动时初始化，这个过程可能会有一定的开销。
- 性能影响：对于大量使用intern()的场景，如果StringTable中已经存在对应的字符串，那么性能不会有太大影响；但如果字符串池中不存在对应的字符串，则需要将字符串添加到池中，这个过程可能会有些性能开销。
总的来说，String.intern()是一个非常有用的方法，特别是在需要重用字符串的场景中。
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中的内存使用。
到此这篇关于JVM系列之String.intern的性能解析的文章就介绍到这了,更多相关String.intern的性能内容请搜索自由互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持自由互联！