一、栈、堆、方法区的交互关系
Person 类的 .class 信息存放在方法区中,person 变量存放在 Java 栈的局部变量表中,真正的 person 对象存放在 Java 堆中
在 person 对象中,有个指针指向方法区中的 person 类型数据, 表明这个 person 对象是用方法区中的 Person 类 new 出来的。
二、方法区的理解
1、方法区的位置
《Java虚拟机规范》中明确说明:尽管所有的方法区在逻辑上是属于堆的一部分,但一些简单的实现可能不会选择去进行垃圾收集或者进行压缩。但对于 HotSpot JVM 而言,方法区还有一个别名叫做 Non-Heap(非堆),目的就是要和堆分开。
所以,方法区可以看作是一块独立于Java堆的内存空间。
方法区与堆一样,是各个线程共享的内存区域,在JVM启动的时候被创建,并且它的实际物理内存空间和堆区一样,都可以是不连续的。
方法区的大小跟堆空间一样,可以选择固定大小或者可扩展,方法区的大小决定了系统可以保存多少个类,如果系统定义了太多的类,导致方法区溢出,虚拟机同样会抛出内存溢出错误:
- java.lang.OutofMemoryError:PermGen space(JDK7之前)
- java.lang.OutOfMemoryError:Metaspace(JDK8之后)
- 加载大量的第三方的jar包
- Tomcat部署的工程过多(30~50个)
- 大量动态的生成反射类
关闭 JVM 就会释放这个区域的内存。
/**
* -Xms600m -Xmx600m
*/
public class EdenSurvivorTest {
public static void main(String[] args) {
System.out.println("我只是来打个酱油~");
try {
Thread.sleep(1000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
简单的程序,加载了好多类
可以看到设置堆内存为 600M 后,年轻代+老年代 = 600M,所以说方法区是不存在堆中的
2、Hotspot中方法区的演进过程
在 JDK7 及以前,习惯上把方法区称为永久代。JDK8 开始,使用元空间取代了永久代。
本质上,方法区和永久代并不等价,仅是对 Hotspot 而言的可以看作等价。《Java虚拟机规范》对如何实现方法区,不做统一要求。
元空间与永久代最大的区别在于:元空间不在虚拟机设置的内存中,而是使用本地内存。
三、设置方法区大小与OOM
JDK7以前 永久代
- 通过 -XX:Permsize 来设置永久代初始分配空间。默认值是20.75M
- 通过 -XX:MaxPermsize 来设定永久代最大可分配空间。32位机器默认是64M,64位机器模式是82M
当 JVM 加载的类信息容量超过了这个值,会报异常 OutofMemoryError:PermGen space。
JDK8及以后 元空间
默认值依赖于平台,Windows下,-XX:MetaspaceSize 约为21M,-XX:MaxMetaspaceSize 的值是 -1,即没有限制,虚拟机会耗尽所有的可用系统内存。如果元数据区发生溢出,虚拟机一样会抛出异常 OutOfMemoryError:Metaspace
对于一个 64 位的服务器端 JVM 来说,其默认的初始的高水位线为 21M,一旦触及这个水位线,Full GC 将会被触发并卸载没用的类(即这些类对应的类加载器不再存活),然后这个高水位线将会重置。新的高水位线的值取决于 GC 后释放了多少元空间,如果释放的空间不足,那么在不超MaxMetaspaceSize 时,适当提高该值,如果释放空间过多,则适当降低该值。
如果初始化的高水位线设置过低,上述高水位线调整情况会发生很多次,即多次调用 Full GC。为了避免频繁地 GC,建议将 -XX:MetaspaceSize 设置为一个相对较高的值。
/**
* 测试设置方法区大小参数的默认值
*
* jdk7及以前:
* -XX:PermSize=100m -XX:MaxPermSize=100m
*
* jdk8及以后:
* -XX:MetaspaceSize=100m -XX:MaxMetaspaceSize=100m
*/
public class MethodAreaDemo {
public static void main(String[] args) {
System.out.println("start...");
try {
Thread.sleep(1000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end...");
}
}
终端命令查看设置的元空间大小
方法区OOM
OOMTest 类继承 ClassLoader 类,获得 defineClass() 方法,可自己进行类的加载
/**
* jdk6/7中:
* -XX:PermSize=10m -XX:MaxPermSize=10m
*
* jdk8中:
* -XX:MetaspaceSize=10m -XX:MaxMetaspaceSize=10m
*/
public class OOMTest extends ClassLoader {
public static void main(String[] args) {
int j = 0;
try {
OOMTest test = new OOMTest();
for (int i = 0; i < 10000; i++) {
//创建ClassWriter对象,用于生成类的二进制字节码
ClassWriter classWriter = new ClassWriter(0);
//指明版本号,修饰符,类名,包名,父类,接口
classWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Class" + i, null, "java/lang/Object", null);
//返回byte[]
byte[] code = classWriter.toByteArray();
//类的加载
test.defineClass("Class" + i, code, 0, code.length); //Class对象
j++;
}
} finally {
System.out.println(j);
}
}
}
不设置元空间的上限,使用默认的 JVM 参数,元空间不设置上限
10000
设置元空间的上限
JVM 参数:-XX:MetaspaceSize=10m -XX:MaxMetaspaceSize=10m
元空间出现 OOM
8531
Exception in thread "main" java.lang.OutOfMemoryError: Metaspace
at java.lang.ClassLoader.defineClass1(Native Method)
at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
at java.lang.ClassLoader.defineClass(ClassLoader.java:642)
at com.charpter9.OOMTest.main(OOMTest.java:31)
解决方法区OOM
1、要解决 OOM 异常或 heap space 的异常,一般的手段是首先通过内存映像分析工具(如Eclipse Memory Analyzer)对 dump 出来的堆转储快照进行分析,重点是确认内存中的对象是否是必要的,也就是要先分清楚到底是出现了内存泄漏(Memory Leak)还是内存溢出(Memory Overflow)
2、内存泄漏就是有大量的引用指向某些对象,但是这些对象以后不会使用了,由于它们还和 GC ROOT 有关联,所以导致这些对象不会被回收,可进一步通过工具查看泄漏对象到 GC Roots 的引用链,就能找到泄漏对象是通过怎样的路径与 GC Roots 相关联并导致垃圾收集器无法自动回收它们的。掌握了泄漏对象的类型信息,以及 GC Roots 引用链的信息,就可以准确地定位出泄漏代码的位置。
3、如果是内存溢出,那就应当检查虚拟机的堆参数(-Xmx与-Xms),与机器物理内存对比看是否还可以调大,从代码上检查是否存在某些对象生命周期过长、持有状态时间过长的情况,尝试减少程序运行期的内存消耗。
四、方法区的内部结构
深入理解Java虚拟机》书中对方法区存储内容描述如下:它用于存储已被虚拟机加载的类型信息、常量、 静态变量、即时编译器编译后的代码缓存等。
类型信息
对每个加载的类型(类class、接口interface、枚举enum、注解annotation),JVM必须在方法区中存储以下类型信息:
- 这个类型的完整有效名称(全类名=包名.类名)
- 这个类型直接父类的完整有效名(对于 interface 或是 java.lang.Object,都没有父类)
- 这个类型的修饰符(public,abstract,final 的某个子集)
- 这个类型直接接口的一个有序列表
域(Field)信息
JVM 必须在方法区中保存类型的所有域的相关信息以及域的声明顺序,域信息通俗来讲是类的成员变量。域的相关信息包括:域名称、域类型、域修饰符(public,private,protected,static,final,volatile,transient的某个子集)
方法(Method)信息
JVM必须保存所有方法的以下信息,同域信息一样包括声明顺序:
- 方法名称
- 方法的返回类型(包括 void 返回类型),void 在Java中对应的类为 void.class
- 方法参数的数量和类型(按顺序)
- 方法的修饰符(public,private,protected,static,final,synchronized,native,abstract的一个子集)
- 方法的字节码(bytecodes)、操作数栈、局部变量表及大小(abstract和native方法除外)
- 异常表(abstract 和 native 方法除外),异常表记录每个异常处理的开始位置、结束位置、代码处理在程序计数器中的偏移地址、被捕获的异常类的常量池索引
没被final修饰的类变量
静态变量和类关联在一起,随着类的加载而加载,他们成为类数据在逻辑上的一部分。
/**
* 测试方法区的内部构成
*/
public class MethodInnerStrucTest extends Object implements Comparable<String>, Serializable {
//属性
public int num = 10;
private static String str = "测试方法的内部结构";
//构造器没写
//方法
public void test1() {
int count = 20;
System.out.println("count = " + count);
}
public static int test2(int cal) {
int result = 0;
try {
int value = 30;
result = value / cal;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
@Override
public int compareTo(String o) {
return 0;
}
}
反编译字节码文件,并输出到文本文件中,便于查看
// 参数 -p 确保能查看 private 权限类型的字段或方法
javap -v -p MethodInnerStrucTest.class > Text.txt
//类型信息
//在运行时方法区中,类信息中记录了哪个加载器加载了该类,同时类加载器也记录了它加载了哪些类
//从反编译文件可以看出,字节码文件记录了MethodInnerStrucTest 继承了哪些类,实现了哪些方法
public class com.charpter9.MethodInnerStrucTest extends java.lang.Object implements java.lang.Comparable<java.lang.String>, java.io.Serializable
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
//域信息
//descriptor: I 表示字段类型为 Integer
//flags: ACC_PUBLIC 表示字段权限修饰符为 public
public int num;
descriptor: I
flags: ACC_PUBLIC
private static java.lang.String str;
descriptor: Ljava/lang/String;
flags: ACC_PRIVATE, ACC_STATIC
//方法信息
//descriptor: ( )V 表示方法返回值类型为 void
//flags: ACC_PUBLIC 表示方法权限修饰符为 public
//stack=3 表示操作数栈深度为 3
//locals=2 表示局部变量个数为 2 个(实力方法包含 this)
//test1( ) 方法虽然没有参数,但是其 args_size=1 ,这是因为将 this 作为了参数
public void test1();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=3, locals=2, args_size=1
0: bipush 20
2: istore_1
3: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
6: new #4 // class java/lang/StringBuilder
9: dup
10: invokespecial #5 // Method java/lang/StringBuilder."<init>":()V
13: ldc #6 // String count =
15: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
18: iload_1
19: invokevirtual #8 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
22: invokevirtual #9 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
25: invokevirtual #10 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
28: return
LineNumberTable:
line 22: 0
line 23: 3
line 24: 28
LocalVariableTable:
Start Length Slot Name Signature
0 29 0 this Lcom/charpter9/MethodInnerStrucTest;
3 26 1 count I
补充说明:全局常量 static final
被声明为 final 的类变量的处理方法则不同,每个全局常量在编译的时候就会被分配了。
如下代码所示,即使我们把 order 设置为 null,也不会出现空指针异常,这表明 static 类型的字段和方法随着类的加载而加载,并不属于特定的类实例。
/**
* non-final的类变量
*/
public class MethodAreaTest {
public static void main(String[] args) {
Order order = null;
order.hello();
System.out.println(order.count);
}
}
class Order {
public static int count = 1;
public static final int number = 2;
public static void hello() {
System.out.println("hello!");
}
}
反编译,查看字节码指令,可以发现 number 的值已经写死在字节码文件中了
public static int count;
descriptor: I
flags: ACC_PUBLIC, ACC_STATIC
public static final int number;
descriptor: I
flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL
ConstantValue: int 2
运行时常量池 vs 常量池
方法区内部包含了运行时常量池,字节码文件内部包含了常量池,要弄清楚方法区,需要理解清楚字节码文件,因为加载类的信息都在方法区,要弄清楚方法区的运行时常量池,需要理解清楚字节码文件中的常量池。
一个有效的字节码文件中除了包含类的版本信息、字段、方法以及接口等描述符信息外,还包含一项信息就是常量池表(Constant Pool Table),包括各种字面量和对类型、域、方法的符号引用。
为什么需要常量池?
一个 Java 源文件中的类、接口,编译后产生一个字节码文件,而 Java 中的字节码需要数据支持,通常这种数据会很大以至于不能直接存到字节码里,可以存到常量池。这个字节码包含了指向常量池的引用,在动态链接的时候会用到运行时常量池。
public class SimpleClass {
public void sayHello() {
System.out.println("hello");
}
}
虽然上述代码只有 194 字节,但是里面却使用了 String、System、PrintStream 及 Object等结构。如果不使用常量池,就需要将用到的类信息、方法信息等记录在当前的字节码文件中,造成文件臃肿,所以我们将所需用到的结构信息记录在常量池中,并通过引用的方式,来加载、调用所需的结构。
常量池表是 Class 字节码文件的一部分,用于存放编译期生成的各种字面量与符号引用,这部分内容将在类加载后存放到方法区的运行时常量池中。常量池可以看做是一张表,虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等信息。
JVM为每个已加载的类或接口都维护一个常量池,池中的数据项像数组项一样,是通过索引访问的。
常量池中有什么?
数量值,字符串值,类引用,字段引用,方法引用
/**
* 测试方法区的内部构成
*/
public class MethodInnerStrucTest extends Object implements Comparable<String>, Serializable {
//属性
public int num = 10;
private static String str = "测试方法的内部结构";
//构造器没写
//方法
public void test1() {
int count = 20;
System.out.println("count = " + count);
}
public static int test2(int cal) {
int result = 0;
try {
int value = 30;
result = value / cal;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
@Override
public int compareTo(String o) {
return 0;
}
}
来看下最简单的 test1() 方法,带 # 的字节码指令,就使用到了常量池的引用。
public void test1();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=3, locals=2, args_size=1
0: bipush 20
2: istore_1
3: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
6: new #4 // class java/lang/StringBuilder
9: dup
10: invokespecial #5 // Method java/lang/StringBuilder."<init>":()V
13: ldc #6 // String count =
15: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
18: iload_1
19: invokevirtual #8 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
22: invokevirtual #9 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
25: invokevirtual #10 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
28: return
LineNumberTable:
line 17: 0
line 18: 3
line 19: 28
LocalVariableTable:
Start Length Slot Name Signature
0 29 0 this Lcn/sxt/java/MethodInnerStrucTest;
3 26 1 count I
常量池
Constant pool:
#1 = Methodref #18.#52 // java/lang/Object."<init>":()V
#2 = Fieldref #17.#53 // cn/sxt/java/MethodInnerStrucTest.num:I
#3 = Fieldref #54.#55 // java/lang/System.out:Ljava/io/PrintStream;
#4 = Class #56 // java/lang/StringBuilder
#5 = Methodref #4.#52 // java/lang/StringBuilder."<init>":()V
#6 = String #57 // count =
#7 = Methodref #4.#58 // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
#8 = Methodref #4.#59 // java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
#9 = Methodref #4.#60 // java/lang/StringBuilder.toString:()Ljava/lang/String;
#10 = Methodref #61.#62 // java/io/PrintStream.println:(Ljava/lang/String;)V
#11 = Class #63 // java/lang/Exception
#12 = Methodref #11.#64 // java/lang/Exception.printStackTrace:()V
#13 = Class #65 // java/lang/String
#14 = Methodref #17.#66 // cn/sxt/java/MethodInnerStrucTest.compareTo:(Ljava/lang/String;)I
#15 = String #67 // 测试方法的内部结构
#16 = Fieldref #17.#68 // cn/sxt/java/MethodInnerStrucTest.str:Ljava/lang/String;
#17 = Class #69 // cn/sxt/java/MethodInnerStrucTest
#18 = Class #70 // java/lang/Object
#19 = Class #71 // java/lang/Comparable
#20 = Class #72 // java/io/Serializable
#21 = Utf8 num
#22 = Utf8 I
#23 = Utf8 str
#24 = Utf8 Ljava/lang/String;
#25 = Utf8 <init>
#26 = Utf8 ()V
#27 = Utf8 Code
#28 = Utf8 LineNumberTable
#29 = Utf8 LocalVariableTable
#30 = Utf8 this
#31 = Utf8 Lcn/sxt/java/MethodInnerStrucTest;
#32 = Utf8 test1
#33 = Utf8 count
#34 = Utf8 test2
#35 = Utf8 (I)I
#36 = Utf8 value
#37 = Utf8 e
#38 = Utf8 Ljava/lang/Exception;
#39 = Utf8 cal
#40 = Utf8 result
#41 = Utf8 StackMapTable
#42 = Class #63 // java/lang/Exception
#43 = Utf8 compareTo
#44 = Utf8 (Ljava/lang/String;)I
#45 = Utf8 o
#46 = Utf8 (Ljava/lang/Object;)I
#47 = Utf8 <clinit>
#48 = Utf8 Signature
#49 = Utf8 Ljava/lang/Object;Ljava/lang/Comparable<Ljava/lang/String;>;Ljava/io/Serializable;
#50 = Utf8 SourceFile
#51 = Utf8 MethodInnerStrucTest.java
#52 = NameAndType #25:#26 // "<init>":()V
#53 = NameAndType #21:#22 // num:I
#54 = Class #73 // java/lang/System
#55 = NameAndType #74:#75 // out:Ljava/io/PrintStream;
#56 = Utf8 java/lang/StringBuilder
#57 = Utf8 count =
#58 = NameAndType #76:#77 // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
#59 = NameAndType #76:#78 // append:(I)Ljava/lang/StringBuilder;
#60 = NameAndType #79:#80 // toString:()Ljava/lang/String;
#61 = Class #81 // java/io/PrintStream
#62 = NameAndType #82:#83 // println:(Ljava/lang/String;)V
#63 = Utf8 java/lang/Exception
#64 = NameAndType #84:#26 // printStackTrace:()V
#65 = Utf8 java/lang/String
#66 = NameAndType #43:#44 // compareTo:(Ljava/lang/String;)I
#67 = Utf8 测试方法的内部结构
#68 = NameAndType #23:#24 // str:Ljava/lang/String;
#69 = Utf8 cn/sxt/java/MethodInnerStrucTest
#70 = Utf8 java/lang/Object
#71 = Utf8 java/lang/Comparable
#72 = Utf8 java/io/Serializable
#73 = Utf8 java/lang/System
#74 = Utf8 out
#75 = Utf8 Ljava/io/PrintStream;
#76 = Utf8 append
#77 = Utf8 (Ljava/lang/String;)Ljava/lang/StringBuilder;
#78 = Utf8 (I)Ljava/lang/StringBuilder;
#79 = Utf8 toString
#80 = Utf8 ()Ljava/lang/String;
#81 = Utf8 java/io/PrintStream
#82 = Utf8 println
#83 = Utf8 (Ljava/lang/String;)V
#84 = Utf8 printStackTrace
运行时常量池
运行时常量池是方法区的一部分,在加载类和接口到虚拟机后,就会创建对应的运行时常量池。运行时常量池中包含多种不同的常量,包括编译期就已经明确的数值字面量,也包括到运行期解析后才能够获得的方法或者字段引用,此时不再是常量池中的符号地址了,这里换为真实地址。
运行时常量池,相对于常量池的另一重要特征是:具备动态性。
五、方法区使用举例
public class MethodAreaDemo {
public static void main(String[] args) {
int x = 500;
int y = 100;
int a = x / y;
int b = 50;
System.out.println(a + b);
}
}
0 sipush 500
3 istore_1
4 bipush 100
6 istore_2
7 iload_1
8 iload_2
9 idiv
10 istore_3
11 bipush 50
13 istore 4
15 getstatic #2 <java/lang/System.out>
18 iload_3
19 iload 4
21 iadd
22 invokevirtual #3 <java/io/PrintStream.println>
25 return
图解字节码指令执行流程
#2 <java/lang/System.out>
#3 <java/io/PrintStream.println>
invokevirtual:执行println方法,会在main方法对应的栈帧上创建新的栈帧,执行完毕后再继续执行main方法对应的栈帧。
关于【符号引用 --> 直接引用】的理解
上面代码调用 System.out.println() 方法时,首先需要看 System 类有没有加载,再看看 PrintStream 类有没有加载,如果没有加载,则执行加载,执行时将常量池中的符号引用(字面量)转换为直接引用(真正的地址值)
六、方法区的演进细节
1、方法区的演进细节
首先明确:只有Hotspot才有永久代。 BEA JRockit、IBMJ9 等来说,是不存在永久代的概念的。
Hotspot中方法区的变化:
JDK 版本 | 演变细节 |
JDK1.6及以前 | 有永久代,静态变量存储在永久代上 |
JDK1.7 | 有永久代,但已经逐步 “去永久代”,字符串常量池、静态变量从永久代中移除,保存在堆中 |
JDK1.8 | 无永久代,类型信息,字段,方法,常量保存在本地内存的元空间,但字符串常量池、静态变量仍然在堆中。 |
2、永久代为什么要被元空间替代
1)为永久代设置空间大小是很难确定的,在某些场景下,如果动态加载类过多,永久代容易产生 OOM。比如某个实际Web工程中,因为功能点比较多,在运行过程中,要不断动态地加载很多类,经常出现致命错误。元空间和永久代之间最大的区别在于,元空间并不在虚拟机中,而是使用本地内存。
2)对永久代进行调优是很困难的。
3、字符串常量池 StringTable 为什么要调整位置?
JDK7 中将 StringTable 放到了堆空间中,因为永久代的回收效率很低,在 Full GC 的时候才会执行永久代的垃圾回收,而 Full GC 是老年代的空间不足、永久代不足时才会触发。这就导致 StringTable 回收效率不高,而开发中会有大量的字符串被创建,回收效率低会导致永久代内存不足,放到堆里能及时回收内存。
4、静态变量放在哪里?
静态变量在 jdk6 存在于永久代中,在 jdk7/8 存在于堆中。//private static byte[] arr
静态引用对应的对象实体始终都存在堆空间 //new byte[1024 * 1024 * 100];
public class StaticFieldTest {
private static byte[] arr = new byte[1024 * 1024 * 100]; //100MB
public static void main(String[] args) {
System.out.println(StaticFieldTest.arr);
}
}
通过 GC 日志可以看出:静态变量引用对应的对象实体始终都在堆空间中
/**
* 《深入理解Java虚拟机》中的案例:
* staticObj、instanceObj、localObj存放在哪里?
*/
public class StaticObjTest {
static class Test {
//静态属性
static ObjectHolder staticObj = new ObjectHolder();
//非静态属性
ObjectHolder instanceObj = new ObjectHolder();
void foo() {
//局部变量
ObjectHolder localObj = new ObjectHolder();
System.out.println("done");
}
}
private static class ObjectHolder {
}
public static void main(String[] args) {
Test test = new StaticObjTest.Test();
test.foo();
}
}
分析:staticObj 随着 Test 的类型信息存放在方法区,instanceObj 随着 Test 的对象实例存放在Java 堆,localObject 则是存放在 foo() 方法栈帧的局部变量表中。
测试发现:三个对象的数据在内存中的地址都落在 Eden 区范围内,所以结论:只要是对象实例必然会在Java堆中分配。
七、方法区的垃圾回收
方法区的垃圾收集主要回收两部分内容:常量池中废弃的常量和不再用的类型,方法区的调优主要是为了降低 Full GC 。一般来说这个区域的回收效果比较难令人满意,尤其是类型的卸载,条件相当苛刻,但是这部分区域的回收有时又确实是必要的。以前Sun公司的Bug列表中,曾出现过的若干个严重的Bug就是由于低版本的HotSpot虚拟机对此区域未完全回收而导致内存泄漏。
1、方法区常量的回收
方法区内的常量池主要存放的两大类常量:字面量和符号引用。
字面量比较接近Java语言层次的常量概念,如文本字符串、被声明为 final 的常量值等
符号引用则属于编译原理方面的概念,包括下面三类常量:
- 类和接口的全限定名
- 字段的名称和描述符
- 方法的名称和描述符
HotSpot 虚拟机对常量池的回收策略是很明确的,只要常量池中的常量没有被任何地方引用,就可以被回收,回收废弃常量与回收 Java 堆中的对象非常类似。
2、方法区类的回收
判定一个常量是否“废弃”还是相对简单,而要判定一个类型是否属于“不再被使用的类”的条件就比较苛刻了。需要同时满足下面三个条件:
- 该类所有的实例都已经被回收,也就是 Java 堆中不存在该类及其任何派生子类的实例。
- 加载该类的类加载器已经被回收,这个条件除非是经过精心设计的可替换类加载器的场景,否则通常是很难达成的。
- 该类对应的 java.lang.Class 对象没有在任何地方被引用,无法在任何地方通过反射访问该类的方法。
Java 虚拟机被允许对满足上述三个条件的无用类进行回收,这里说的仅仅是“被允许”,而并不是和对象一样,没有引用了就必然会回收。关于是否要对类型进行回收,HotSpot虚拟机提供了-Xnoclassgc 参数进行控制,还可以使用 -verbose:class 以及 -XX:+TraceClass-Loading、-XX:+TraceClassUnLoading查看类加载和卸载信息。
在大量使用反射、动态代理、CGLIB 等字节码框架,动态生成 JSP 以及 OSGi 这类频繁自定义类加载器的场景中,通常都需要 Java 虚拟机具备类型卸载的能力,以保证不会对方法区造成过大的内存压力。