深入理解 Java String#intern() 内存模型

澳门新浦京app下载 8

大家知道,Java中string.intern()方法调用会先去字符串常量池中查找相应的字符串,如果字符串不存在,就会在字符串常量池中创建该字符串然后再返回。

String是Java基础的重要考点。可问的点多,而且很多点可以横向切到其他考点,或纵向深入JVM。

澳门新浦京app下载 1

字符串常量池是一个固定大小的HashMap,桶的数量默认是1009,
从Java7u40开始,该默认值增大到60013。在Java6当中,字符串常量池是放在Perm空间的,从Java7开始,字符串常量池被移到Heap空间。下面,我们通过测试程序来窥探字符串常量池在Java6,Java7两个不同版本底下的内存分配情况。

本文略过了String的基本内容,重点在于String#intern()。

Java虚拟机运行时数据区

测试程序

public class StringPoolTest {

    public void testStringPoolWithLongString(){
        long i=0;
        while(true){
            String longString = "This is a very long string, very very long string to test the gc behavior of the string constant pool"+i;
            longString.intern();
            i++;
        }
    }

    public static void main(String[] args){
        StringPoolTest stringPoolTest = new StringPoolTest();
        stringPoolTest.testStringPoolWithLongString();
    }
}

测试程序很简单,一个死循环,循环里面通过递增变量i制造唯一的字符串,然后用main函数启动程序。

String常量池

String常量可能会在两种时机进入常量池:

  1. 编译期:通过双引号声明的常量(包括显示声明静态编译优化后的常量,如”1”+”2”优化为常量”12”),在前端编译期将被静态的写入class文件中的“常量池”。该“常量池”会在类加载后被载入“内存中的常量池”,也就是我们平时所说的常量池。同时,JIT优化也可能产生类似的常量。
  • 运行期:调用String#intern()方法,可能将该String对象动态的写入上述“内存中常量池”。

时机1的行为是明确的。原理可阅读class文件结构、类加载、编译期即运行期优化等内容。

时机2在jdk6和jdk7中的行为不同,下面讨论。

1.1 程序计数器

作用:
它可以看作是当前线程所执行的字节码的行号指示器;为了线程切换后能恢复到正确的执行位置,每条线程都需要有一个独立的程序计数器,各条线程之间计数器互不影响,独立存储(线程私有)。
如果线程正在执行的是一个Java方法,计数器记录的是正在执行的虚拟机字节码指令的地址;如果线程正在执行的是Native方法,计数器值为空。

异常状况:
此内存区域是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。

Java 6

我们使用版本Jdk1.6.0_29来跑该程序,打开Java
VisualVM监控,可以看到,Perm区不断发生GC,由此的出结论,虽然字符串常量池放在Perm空间,但当Perm空间接近满的时候,JVM会将字符串常量池中的无用字符串回收掉。

澳门新浦京app下载 2

String#intern()

读者可直接阅读参考资料。下述总结仅为了猴子自己复习方便。

1.2 Java虚拟机栈

作用:
Java虚拟机栈的生命周期与线程相同。虚拟机栈描述的是Java方法执行的内存模型:每个方法在执行的同时都会创建一个栈帧(一个方法一个栈帧)用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行完成的过程,就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。
一个线程中的方法可能还会调用其他方法,这样就会构成方法调用链,而且这个链可能会很长,而且每个线程都有方法处于执行状态。对于执行引擎来说,只有活动线程栈顶的栈帧才是有效的,称为当前栈帧(Current
Stack Frame),这个栈帧关联的方法称为当前方法(Current Method)。

澳门新浦京app下载 3

image.png

澳门新浦京app下载 4

image.png

局部变量表:存放编译器可知的各种基本数据类型、对象引用和returnAddress类型。其中64位长度的long和double类型的数据占用2个局部变量空间,其余的数据类型只占用1个。局部变量表所需的内存空间在编译期间完成分配,当进入一个方法时,这个方法需要在帧中分配多大的局部变量空间是完全确定的,在方法运行期间不会改变局部变量表的大小。

异常状况:
StackOverflowError异常:线程请求的栈深度大于虚拟机所允许的深度。
OutOfMemoryError异常:虚拟机栈扩展时无法申请到足够的内存。

Java 7

下面,我们切换到Jdk1.7.0_67重跑该程序,可以看到Perm区内存分配曲线很平滑,没有出现内存分配的现象。

澳门新浦京app下载 5

但在Heap空间,新的对象不断产生,然后不断触发GC

澳门新浦京app下载 6

声明

/** 
 * Returns a canonical representation for the string object. 
 * <p> 
 * A pool of strings, initially empty, is maintained privately by the 
 * class <code>String</code>. 
 * <p> 
 * When the intern method is invoked, if the pool already contains a 
 * string equal to this <code>String</code> object as determined by 
 * the {@link #equals(Object)} method, then the string from the pool is 
 * returned. Otherwise, this <code>String</code> object is added to the 
 * pool and a reference to this <code>String</code> object is returned. 
 * <p> 
 * It follows that for any two strings <code>s</code> and <code>t</code>, 
 * <code>s.intern()&nbsp;==&nbsp;t.intern()</code> is <code>true</code> 
 * if and only if <code>s.equals(t)</code> is <code>true</code>. 
 * <p> 
 * All literal strings and string-valued constant expressions are 
 * interned. String literals are defined in section 3.10.5 of the 
 * <cite>The Java&trade; Language Specification</cite>. 
 * 
 * @return  a string that has the same contents as this string, but is 
 *          guaranteed to be from a pool of unique strings. 
 */  
public native String intern();

String#intern()是一个native方法。根据Javadoc,如果常量池中存在当前字符串,
就会直接返回当前字符串. 如果常量池中没有此字符串,
会将此字符串放入常量池中后, 再返回。

1.3 本地方法栈

作用:
本地方法栈与虚拟机栈所发挥的作用非常相似,它们之间的区别是虚拟机栈为虚拟机执行Java方法(字节码)服务,而本地方法栈则为虚拟机使用到的Native方法服务。

异常状况:
澳门新浦京app下载,StackOverflowError异常:线程请求的栈深度大于虚拟机所允许的深度。
OutOfMemoryError异常:虚拟机栈扩展时无法申请到足够的内存。

结论

由于Perm区大小是有限的,通常只有几十MB,所以不推荐在Java6下广泛使用String.intern(),这篇文章string-intern-in-java-6-7-8的性能测试表明,在Java6底下大量使用intern()会导致应用性能的显著下降,还有可能产生OOM错误。但从Java7开始,字符串常量池被移到了Heap空间,Heap空间的大小只受制于机器的真实内存大小,因此,在Java7下使用String.intern()能更有效地减少重复String对象对内存的占用。

实现原理

JNI最后调用了c++实现的StringTable::intern()方法:

oop StringTable::intern(Handle string_or_null, jchar* name,  
                        int len, TRAPS) {  
  unsigned int hashValue = java_lang_String::hash_string(name, len);  
  int index = the_table()->hash_to_index(hashValue);  
  oop string = the_table()->lookup(index, name, len, hashValue);  
  // Found  
  if (string != NULL) return string;  
  // Otherwise, add to symbol to table  
  return the_table()->basic_add(index, string_or_null, name, len,  
                                hashValue, CHECK_NULL);  
}
oop StringTable::lookup(int index, jchar* name,  
                        int len, unsigned int hash) {  
  for (HashtableEntry<oop>* l = bucket(index); l != NULL; l = l->next()) {  
    if (l->hash() == hash) {  
      if (java_lang_String::equals(l->literal(), name, len)) {  
        return l->literal();  
      }  
    }  
  }  
  return NULL;  
}

在the_table()返回的hash表中查找字符串,如果存在就返回,否则加入表。

StringTable是一个固定大小Hashtable,默认大小是1009。基本逻辑与Java中HashMap相同,也使用拉链法解决碰撞问题。

既然是拉链法,那么如果放进的String非常多,就会加剧碰撞,导致链表非常长。最坏情况下,String#intern()的性能由O(1)退化到O(n)。

  • jdk6中StringTable的长度固定为1009。
  • jdk7中,StringTable的长度可以通过一个参数-XX:StringTableSize指定,默认1009。

1.4 Java堆(GC堆)

作用:
Java堆是虚拟机所管理的内存中最大的一块,在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例和数组。
Java堆是垃圾收集器管理的主要区域,因此也被称为“GC堆”。
从内存回收的角度看,由于现在收集器基本都采用分代收集算法,所以Java堆被分为:新生代和老年代;再细致一点:Eden空间、From
Survivor空间、To
Survivor空间等。值得注意的是,从JKD1.7开始,永久代Perm逐渐被移除,最新的JDK1.8中已经使用元空间(MetaSpace)代替永久代。
从内存分配的角度看,线程共享的Java堆中可能划分出多个线程私有的分配缓冲区。

澳门新浦京app下载 7

image.png

澳门新浦京app下载 8

image.png

异常状况:
OutOfMemoryError异常:在堆中没有内存完成实例分配,并且堆也无法扩展。

jdk6和jdk7下String#intern()的区别

1.5 方法区

作用:
用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
这个区域的内存回收目标主要是针对常量池的回收和对类型的卸载。

异常状况:
OutOfMemoryError异常:方法区无法满足内存分配需求

引言

相信很多Java程序员都做类似String s = new String("abc");这个语句创建了几个对象的题目。这种题目主要是为了考察程序员对字符串对象常量池的掌握。上述的语句中创建了2个对象:

  • 第一个对象,内容”abc”,存储在常量池中。
  • 第二个对象,内容”abc”,存储在堆中。

1.6 运行时常量池

常量池(Constant Pool
Table),用于存放编译期生成的各种字面量、符号引用,文字字符串、final变量值、类名和方法名常量,这部分内容将在类加载后存放到方法区的运行时常量池中。它们以数组形式访问,是调用方法、与类联系及类的对象化的桥梁。

运行时常量池除了存放编译期产生的Class文件的常量外,还可存放在程序运行期间生成的新常量,比较常见增加新常量方法有String类的internd()方法。String.intern()是一个Native方法,它的作用是:如果运行时常量池中已经包含一个等于此String对象内容的字符串,则返回常量池中该字符串的引用;如果没有,则在常量池中创建与此String内容相同的字符串,并返回常量池中创建的字符串的引用。不过JDK7的intern()方法的实现有所不同,当常量池中没有该字符串时,不再是在常量池中创建与此String内容相同的字符串,而改为在常量池中记录堆中首次出现的该字符串的引用,并返回该引用。

但是,JDK1.7之前运行时常量池是方法区的一部分,JDK1.7及之后版本已经将运行时常量池从方法区中移了出来,在堆(Heap)中开辟了一块区域存放运行时常量池。

问题

来看一段代码:

public static void main(String[] args) {
    String s = new String("1");
    s.intern();
    String s2 = "1";
    System.out.println(s == s2);

    String s3 = new String("1") + new String("1");
    s3.intern();
    String s4 = "11";
    System.out.println(s3 == s4);
}

打印结果:

# jdk6下
false false
# jdk7下
false true

具体为什么稍后再解释,然后将s3.intern();语句下调一行,放到String s4 = "11";后面。将s.intern();放到String s2 = "1";后面:

public static void main(String[] args) {
    String s = new String("1");
    String s2 = "1";
    s.intern();
    System.out.println(s == s2);

    String s3 = new String("1") + new String("1");
    String s4 = "11";
    s3.intern();
    System.out.println(s3 == s4);
}

打印结果:

# jdk6下
false false
# jdk7下
false false

1.7 直接内存

直接内存(Direct
memory)并不是JVM运行时数据区的一部分,也不是Java虚拟机规范中定义的内存区域。但这部分内存也被频繁使用,而且它也可能导致OutOfMemoryError异常出现。

本机直接内存的分配不会受到Java堆大小的限制,但是,还是会受到本机总内存(包括RAM及SWAP区或者分页文件)的大小及处理器寻址空间的限制,从而导致动态扩展时出现OutOfMemoryError异常。

jdk6的解释

image.png

注:图中绿色线条代表String对象的内容指向;黑色线条代表地址指向。

jdk6中,上述的所有打印都是false。

因为jdk6的常量池放在Perm区中,和正常的Heap(指Eden、Surviver、Old区)完全分开。具体来说:使用引号声明的字符串都是通过编译和类加载直接载入常量池,位于Perm区;new出来的String对象位于Heap(E、S、O)中。拿一个Perm区的对象地址和Heap中的对象地址进行比较,肯定是不相同的。

Perm区主要存储一些加载类的信息、静态变量、方法片段、常量池等。

jdk7的解释

在jdk6及之前的版本中,字符串常量池都是放在Perm区的。Perm区的默认大小只有4M,如果多放一些大字符串,很容易抛出OutOfMemoryError: PermGen space

因此,jdk7已经将字符串常量池从Perm区移到正常的Heap(E、S、O)中了。

Perm区即永久代。本身用永久代实现方法区就容易遇到内存溢出;而且方法区存放的内容也很难估计大小,没必要放在堆中管理。jdk8已经取消了永久代,在堆外新建了一个Metaspace实现方法区。

正是因为字符串常量池移到了Heap中,才产生了上述变化。

第一段代码

image.png

先看s3和s4:

  • 首先,String s3 = new String("1") + new String("1");,生成了多个对象,s3最终指向堆中的”11″。注意,此时常量池中是没有字符串”11″的。
  • 然后,s3.intern();,将s3中的字符串”11″放入了常量池中,因为此时常量池中不存在字符串”11″,因此常规做法与跟jdk6相同,在常量池中生成一个String对象”11″——然而,jdk7中常量池不在Perm区中了,相应做了调整:常量池中不需要再存储一份对象了,而是直接存储堆中的引用,也就是s3的引用地址。
  • 接下来,String s4 = "11";,”11″通过双引号显示声明,因此会直接去常量池中查找,如果没有再创建。发现已经有这个字符串了,也就是刚才通过s3.intern();存储在常量池中的s3的引用地址。于是,直接返回s3的引用地址,s4赋值为s3的引用,s4指向堆中的”11″
  • 最后,s3、s4指向的堆中的”11″,常量池中存储s3的引用,满足s3 == s4

再看s和s2:

  • 首先,String s = new String("1");,生成了2个对象,常量池中的”1″和堆中的”1″,s指向堆中的”1″
  • 然后,s.intern();,上一句已经在常量池中创建了”1″,所以此处什么都不做。
  • 接下来,,String s2 = "1";,常量池中有”1″,因此,s2直接指向常量池中的”1″
  • 最后,s指向的堆中的”1″,s2指向常量池中的”1″,常量池中存储字符串”1″,不满足s == s2

第二段代码

image.png

先看s3和s4,将s3.intern();放在了String s4 = "11";后:

  • 先执行String s4 = "11";,此时,常量池中不存在”11″,因此,将”11″放入常量池,然后s4指向常量池中的”11″
  • 再执行s3.intern();,上一句已经在常量池中创建了”11″,所以此处什么都不做。
  • 最后,s3仍指向的堆中的”11″,s4指向常量池中的”11″,常量池中存储字符串”11″,不再满足s3 == s4

再看s和s2,将s.intern();放到String s2 = "1";后:

  • 先执行String s2 = "1";,之前已通过String s = new String("1");在常量池中创建了”1″,因此,s2直接指向常量池中的”1″
  • 再执行s.intern();,常量池中有”1″,所以此处什么都不做。
  • 最后,s指向的堆中的”1″,s2指向常量池中的”1″,常量池中存储字符串”1″,仍不满足s == s2

区别小结

jdk7与jdk6相比,对String常量池的位置、String#intern()的语义都做了修改:

  • 将String常量池从Perm区移到了Heap区。
  • 调用String#intern()方法时,堆中有该字符串而常量池中没有,则直接在常量池中保存堆中对象的引用,而不会在常量池中重新创建对象。

使用姿势

建议直接阅读参考资料。

额外的问题

String#intern()的基本用法如下:

String s1 = xxx1.toString().intern();
String s2 = xxx2.toString().intern();
assert s1 == s2;

然而,xxx1.toString()xxx2.toString()已经创建了两个匿名String对象,这之后再调用String#intern()。那么,这两个匿名对象去哪了

估计猴子对创建对象的过程理解有问题,或许xxx1.toString()返回时还没有将对象保存到堆上?或许String#intern()上做了什么语法糖?

后面有时间再解决吧。。。


参考:

  • 深入解析String#intern

本文链接:

本文链接:String常量池和String#intern()
作者:猴子007
出处:https://monkeysayhi.github.io
本文基于知识共享署名-相同方式共享
4.0国际许可协议发布,欢迎转载,演绎或用于商业目的,但是必须保留本文的署名及链接。

You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图