JDK方法区、元空间区别 & String.intern相关面试题

电玩女神 2023-09-28 11:06 15阅读 0赞

## 一、方法区、永久代、元空间 ##

## 1.方法区、永久代 ##

方法区也是各个线程共享的内存区域，它用于存储已经被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

方法区域又被称为“永久代”，但这仅仅对于Sun HotSpot来讲，JRockit和IBM J9虚拟机中并不存在永久代的概念。

Java虚拟机规范把方法区描述为Java堆的一个逻辑部分，而且它和Java Heap一样不需要连续的内存，可以选择固定大小或可扩展，另外，虚拟机规范允许该区域可以选择不实现垃圾回收。

相对而言，垃圾收集行为在这个区域比较少出现。该区域的内存回收目标主要针是对废弃常量的和无用类的回收。

运行时常量池是方法区的一部分，Class文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息是常量池（Class文件常量池）， **用于存放编译器生成的各种字面量和符号引用** ，这部分内容将在类加载后存放到方法区的运行时常量池中。

运行时常量池相对于Class文件常量池的另一个重要特征是具备动态性，Java语言并不要求常量一定只能在编译期产生，也就是并非预置入Class文件中的常量池的内容才能进入方法区的运行时常量池，运行期间也可能将新的常量放入池中，这种特性被开发人员利用比较多的是String类的intern()方法。

## 2.变更历史 ##

在JDK1.7之前 **运行时常量池** 逻辑包含字符串常量池存放在方法区, 此时hotspot虚拟机对方法区的实现为永久代

在JDK1.7 **字符串常量池** 被从方法区拿到了堆（方法区是堆的一个逻辑分区）中, 这里没有提到运行时常量池,也就是说字符串常量池被单独拿到堆,运行时常量池剩下的东西还在方法区, 也就是hotspot中的永久代

在JDK1.8及之后 hotspot移除了永久代用 **元空间** (Metaspace)取而代之, 这时候字符串常量池还在堆, 运行时常量池还在方法区, 只不过方法区的实现从永久代变成了元空间(Metaspace)。

如下图Java堆内存结构，注意，在Java虚拟机规范将永久代（方法区）中描述为Java堆的一个逻辑部分。

![d1e5011e36263f0aea348e7300bb2173.png][]

## 二、元空间 ##

JDK8 HotSpot JVM 将永久代移除，使用本地内存来存储类元数据信息并称之为：元空间（Metaspace）。

以下是JVM内存模型中方法区的变动：

![6b0e3a1460b5926a6b34109395eab796.png][]

1.  新生代：Eden+From Survivor+To Survivor
2.  老年代：OldGen
3.  永久代（方法区的实现） : PermGen替换为Metaspace(本地内存中)

方法区和“PermGen space”又有着本质的区别。 **前者是 JVM 的规范，而后者则是 JVM 规范的一种实现** ，并且只有 HotSpot 才有 “PermGen space”，而对于其他类型的虚拟机，如 JRockit（Oracle）、J9（IBM） 并没有“PermGen space”。由于方法区主要存储类的相关信息，所以对于动态生成类的情况比较容易出现永久代的内存溢出。

元空间的本质和永久代类似，都是对JVM规范中方法区的实现。不过元空间与永久代之间最大的区别在于：元空间并不在虚拟机中，而是使用本地内存。因此，默认情况下，元空间的大小仅受本地内存限制，但可以通过以下参数来指定元空间的大小：

-XX:MetaspaceSize，初始空间大小，达到该值就会触发垃圾收集进行类型卸载，同时GC会对该值进行调整：如果释放了大量的空间，就适当降低该值；如果释放了很少的空间，那么在不超过MaxMetaspaceSize时，适当提高该值。  -XX:MaxMetaspaceSize，最大空间，默认是没有限制的。
     除了上面两个指定大小的选项以外，还有两个与 GC 相关的属性：  -XX:MinMetaspaceFreeRatio，在GC之后，最小的Metaspace剩余空间容量的百分比，减少为分配空间所导致的垃圾收集  -XX:MaxMetaspaceFreeRatio，在GC之后，最大的Metaspace剩余空间容量的百分比，减少为释放空间所导致的垃圾收集

## 2.变动原因 ##

字符串存在永久代中，现实使用中易出问题, 由于永久代内存经常不够用或发生内存泄露，爆出异常  
java.lang.OutOfMemoryError: PermGen

类及方法的信息等比较难确定其大小，因此对于永久代的大小指定比较困难，太小容易出现永久代溢出，太大则容易导致老年代溢出。

永久代会为 GC 带来不必要的复杂度，并且回收效率偏低。

This is part of the JRockit and Hotspot convergence effort. JRockit customers do not need to configure the permanent generation (since JRockit does not have a permanent generation) and are accustomed to not configuring the permanent generation.

即：移除永久代是为融合HotSpot JVM与 JRockit VM而做出的努力，因为JRockit没有永久代，不需要配置永久代。

## 3.移除永久代的影响 ##

由于类的元数据分配在本地内存中，元空间的最大可分配空间就是系统可用内存空间。因此，我们就 不会遇到永久代存在时的内存溢出错误，也不会出现泄漏的数据移到交换区这样的事情 。最终用户可以为元空间设置一个可用空间最大值，如果不进行设置，JVM会自动根据类的元数据大小动态增加元空间的容量。

注意：永久代的移除并不代表自定义的类加载器泄露问题就解决了。因此，你还必须监控你的内存消耗情况，因为一旦发生泄漏，会占用你的大量本地内存，并且还可能导致交换区交换更加糟糕。

了解更多： 元空间的内存管理

## 三、String.intern面试题 ##

## 1.intern()方法解释 ##

intern() 方法返回字符串对象的规范化表示形式。

它遵循以下规则：对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 因为 true。

String.intern方法究竟做了什么？jdk源码中对intern方法的详细解释为：

Returns a canonical representation for the string object. A pool of strings, initially empty, is maintained privately by the class String. When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned. It follows that for any two strings s and t, s.intern() == t.intern() is true if and only if s.equals(t) is true. All literal strings and string-valued constant expressions are interned. String literals are defined in section 3.10.5 of the The Java? Language Specification.

简单来说就是intern用来返回常量池中的某字符串，如果常量池中已经存在该字符串，则直接返回常量池中该对象的引用。否则，在常量池中加入该对象，然后 返回引用。(这里的加入该对象对于java1.7前后的处理方式不同, 往后看)

## 2.实例 ##

看下一个例子：

String str1 = "a";
    String str2 = "b";
    String str3 = "ab";
    String str4 = str1 + str2;
    String str5 = new String("ab");
    
    System.out.println(str5.equals(str3));        // true
    System.out.println(str5 == str3);             // false
    System.out.println(str5.inter() == str3);     // true
    System.out.println(str5.inter() == str4);     // false

为什么会得到这样的一个结果呢？我们一步一步地分析。

第一、str5.equals(str3)这个结果为true，不用太多的解释，因为字符串的值的内容相同。

第二、str5 == str3对比的是引用的地址是否相同，由于str5采用new String方式定义的，所以地址引用一定不相等。所以结果为false。

第三、当str5调用intern的时候，会检查字符串池中是否含有该字符串。由于之前定义的str3已经进入字符串池中，所以会得到相同的引用。

第四，当str4 = str1 + str2后，str4的值也为”ab”，但是为什么这个结果会是false呢？先看下面代码：

String a = new String("ab");
    String b = new String("ab");
    String c = "ab";
    String d = "a" + "b";
    String e = "b";
    String f = "b" + e;
    
    System.out.println(b.intern() == a);     // false
    System.out.println(b.intern() == c);     // true
    System.out.println(b.intern() == d);     // true
    System.out.println(b.intern() == f);     // false
    System.out.println(b.intern() == a.intern());     // true

由运行结果可以看出来，b.intern() == a和b.intern() == c可知，采用new 创建的字符串对象不进入字符串池，并且通过b.intern() == d和b.intern() == f可知，字符串相加的时候，都是静态字符串的结果会添加到字符串池，如果其中含有变量（如f中的e）则不会进入字符串池中。但是字符串一旦进入字符串池中，就会先查找池中有无此对象。如果有此对象，则让对象引用指向此对象。如果无此对象，则先创建此对象，再让对象引用指向此对象。

## 3.在看《深入理解java虚拟机》中的一个例子: ##

![e54a374d81ee90272df908826c8a82f4.png][]

结果是:

true false

《深入理解java虚拟机》中写道，如果JDK1.6会返回两个false，JDK1.7运行则会返回一个true一个false。

JDK1.6中，intern（）方法会把首次遇到的字符串实例复制到永久代中，返回的也是永久代中这个字符串的实例的引用，而StringBulder创建的字符串实例在Java堆上，所以必然不是同一个引用，将返回false。

JDK1.7中，intern（）的实现不会在复制实例，只是在常量池中记录首次出现的实例引用，因此返回的是引用和由StringBuilder.toString()创建的那个字符串实例是同一个。

str2的比较返回false因为"java"这个字符串在执行StringBuilder.toString()之前已经出现过，字符串常量池中已经有它的引用了，不符合“首次出现”的原则，而“计算机软件”这个字符串是首次出现，因此返回true。(System类自动由java虚拟机调用, 其中把"java"加入到了常量池中)

## 4.总结: ##

*  new String都是在堆上创建字符串对象。当调用 intern() 方法时，编译器会将字符串添加到常量池中（stringTable维护），并返回指向该常量的引用。
 *  通过字面量赋值创建字符串（如：String str=”twm”）时，会先在常量池中查找是否存在相同的字符串，若存在，则将栈中的引用直接指向该字符串；若不存在，则在常量池中生成一个字符串，再将栈中的引用指向该字符串。
 *  常量字符串的“+”操作，编译阶段直接会合成为一个字符串。如string str=”JA”+”VA”，在编译阶段会直接合并成语句String str=”JAVA”，于是会去常量池中查找是否存在”JAVA”,从而进行创建或引用。
 *  常量字符串和变量拼接时（如：String str3=baseStr + “01”;）会调用stringBuilder.append()在堆上创建新的对象。
 *  对于final字段，编译期直接进行了常量替换（而对于非final字段则是在运行期进行赋值处理的）。在编译时，直接替换成了String str3=”ja”+”va”，根据第三条规则，再次替换成String str3=”JAVA”。

final String str1=”ja”;
    final String str2=”va”;
    String str3=str1+str2;

*  JDK 1.7后，intern方法还是会先去查询常量池中是否有已经存在，如果存在，则返回常量池中的引用，这一点与之前没有区别，区别在于，如果在常量池找不到对应的字符串，则不会再将字符串拷贝到常量池，而只是在常量池中生成一个对原字符串的引用。简单的说，就是往常量池放的东西变了：原来在常量池中找不到时，复制一个副本放到常量池，1.7后则是将在堆上的地址引用复制到常量池。

![cc58341d29244449991107147328b1c4.jpeg][]

[d1e5011e36263f0aea348e7300bb2173.png]: https://img-blog.csdnimg.cn/img_convert/d1e5011e36263f0aea348e7300bb2173.png
[6b0e3a1460b5926a6b34109395eab796.png]: https://img-blog.csdnimg.cn/img_convert/6b0e3a1460b5926a6b34109395eab796.png
[e54a374d81ee90272df908826c8a82f4.png]: https://img-blog.csdnimg.cn/img_convert/e54a374d81ee90272df908826c8a82f4.png
[cc58341d29244449991107147328b1c4.jpeg]: https://img-blog.csdnimg.cn/cc58341d29244449991107147328b1c4.jpeg