不懂jvm系列string.intern的性能分析？其实想解决这个问题也不难，下面让小编带着大家一起学习怎么去解决，希望大家阅读完这篇文章后大所收获。
string对象有个特殊的stringtable字符串常量池，为了减少heap中生成的字符串的数量，推荐尽量直接使用string table中的字符串常量池中的元素。
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 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();
}
}
输出结果：
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的性能分析内容对大家有帮助，同时也希望大家多多支持本站，关注本站行业资讯频道，遇到问题就找本站，详细的解决方法等着你来学习!
