随记--方法区--20200518

最新推荐文章于 2024-08-12 11:59:51 发布

dadadadak

最新推荐文章于 2024-08-12 11:59:51 发布

阅读量138

点赞数

分类专栏：随记 JVM

本文链接：https://blog.csdn.net/dadadadak/article/details/106197353

版权

随记同时被 2 个专栏收录

29 篇文章 0 订阅

订阅专栏

JVM

14 篇文章 0 订阅

订阅专栏

本文详细探讨了Java虚拟机中的方法区，包括其与栈、堆的关系，理解方法区的作用，Hotspot中的方法区演进，如永久代被元空间替代的原因。还讨论了方法区的大小设置与OOM问题，内部结构如类型信息、域信息、方法信息、常量池等，并介绍了垃圾收集在方法区的应用。文章最后提到了方法区在实际应用中的例子和优化问题。

摘要由CSDN通过智能技术生成

方法区

1. 栈、堆、方法区的交互关系

Person person = new Person()

Person 方法区
person java栈
new Person() java堆
java栈本地变量表reference指向堆，堆里存有到对象类型数据的指针和对象类型数据。对象类型数据的指针指向方法区的对象类型数据。

2. 方法区的理解

《java虚拟机规范》中明确说明：“尽管所有的方法区在逻辑上是属于堆的一部分，但一些简单的实现可能不会选择去进行垃圾收集或进行压缩。”但对于HotspotJVM而言，方法区还有一个别名叫Non-Heap（非堆），目的就是要和堆分开。
所以，方法区看作是一块独立于Java堆的内存空间。

方法区和java堆一样，是各个线程共享的内存区域。
方法区在jvm启动时被创建，并且它的实际的物理内存空间中和java堆区一样都可以是不连续的。
方法区的大小，跟堆空间一样，可以选择固定大小或者可扩展。
方法区的大小决定了系统可以保存多少个类，如果系统定义了太多的类，导致方法区溢出，虚拟机同样会抛出内存溢出错误：java.lang.OutOfMemoryError:PermGen space（jdk7及以前）或者java.lang.OutOfMemoryError:Metaspace
- 加载大量的第三方的jar包
- Tomcat部署的工程过多（30-50个）
- 大量动态的生成反射类
关闭JVM就会释放这个区域的内存。

Hotspot中的方法区的演进

jdk7及以前，习惯上把方法区称为永久代。jdk8开始，用元空间取代了永久代
本质上，方法区和永久代并不等价。仅是对Hotspot而言的。《java虚拟机规范》对如何hi先方法区，不做统一要求，例如EBA JRockit / IBM J9中没有永久代
- 现在来看，当年使用永久代，不是个好的idea，导致java程序更容易OOM（超过-XX:MaxPermSize上限)
JDK8，终于完全废弃了永久代的概念，改用与JRockit、J9一样在本地内存中实现的元空间来代替。
元空间的本质和永久代类似，都是对JVM规范中方法区的实现。不过元空间与永久代最大的区别是：元空间不在虚拟机设置的内存中，而是使用本机内存。
永久代、元空间二者并不只是名字变了，内部结构也调整了。（字符串常量池、静态变量等）
《java虚拟机规范》中规定，如果方法区无法满足新的内存分配需求时，将抛出OOM异常。

3. 设置方法区的大小与OOM

jdk7及以前：
- 通过-XX:PermSize设置永久代初始分配空间，默认值是20.75M
- -XX: MaxPermSize用来设定永久代最大可分配空间。32位机默认是64M，64位机默认是82M
- 当JVM加载的类信息容量超过了这个值，会报OutOfMemoryError:PermGen space
jdk8以后：
- 通过-XX:MetaspaceSize设置永久代初始分配空间。默认值依赖于平台，windows下默认值是21M
- -XX:MaxMetaspaceSize用来设定永久代最大可分配空间。windows下默认值是-1，即没有限制。
- 与永久代不同，如果不指定大小，默认情况下，虚拟机会耗尽所有的可用系统内存。如果元数据区发生溢出，虚拟机一样会抛出异常java.lang.OutOfMemoryError:Metaspace
- -XX:MetaspaceSize设置初始的元空间大小。对于一个64位的服务器端JVM来说，其默认的-XX:MetaspaceSize值位21MB，这就是初始的高水位线，一旦触及这个水位线，Full GC将会触发并卸载没用的类（即这些类对应的类加载器不再存活），然后这个高水位线会被重置。新的高水位线的值取决于GC后释放了多少元空间。如果释放的空间不足，那么在不超过MaxMetaspaceSize时，应适当提高该值，如果释放空间过多，则适当降低该值。
- 如果初始的高水位线设置过低，上述高水位线调整情况会发生很多次。通过垃圾回收器的日志可以观察到Full GC多次调用。为了避免频繁的GC，建议将该值设置为一个较高的值。

如何解决这些OOM?

要解决OOM异常或heap space的异常，一般的手段是首先通过内存映像工具（如Eclipse Memory Analyzer）对dump出来的堆转储快照进行分析，重点是确认内存中的对象是否是必要的，也就是要先分清楚到底出现了内存泄漏（Memory Leak）还是内存溢出（Memory Overflow）
如果是内存泄漏，可进一步通过工具查看泄漏对象到GC Roots的引用链。于是就能找到泄露对象是通过怎样的路径与GC Roots相关联并导致垃圾收集器无法自动回收它们的。掌握了泄漏对象的类型信息，以及GC Roots引用链的信息，就可以比较准确地定位出泄漏代码的位置。
如果不存在内存泄漏，换句话就是内存中的对象确实都还必须存活着，那就应当检查虚拟机的堆参数（-Xmx和-Xms），与机器物理内存对比看是否还可以调大，从代码上检查是否存在某些对象生命周期过长、持有状态时间过长的情况，尝试减少运行期的内存消耗。

4. 方法区的内部结构

方法区存储什么？

《深入理解java虚拟机》中对方法区存储内容描述如下：
它用于存储已被虚拟机加载的类型信息、常量、静态变量、即时编译器编译后的代码缓存等。

类型信息

对每个加载的类型（类class，接口interface，枚举enum，注解annotation），JVM必须在方法区中存储以下类型信息:

这个类型的完整有效名称（全名=包名.类名）
这个类型直接父类的完整有效名称（对于interface或是java.lang.Object，都没有父类）
这个类型的修饰符（public,abstract,final的某个子集）
这个类型直接接口的一个有序列表

域(Field)信息

JVM必须在方法区中保存类型的所有域的相关信息以及域的生命顺序。
域的相关信息包括：域名称、域类型、域修饰符（public,private,protected,static,final,volatile,transient的某个子集）

方法信息

JVM必须保存所有方法的以下信息，同域信息一样包括声明顺序：

方法名称
方法的返回类型（或void）
方法参数的数量和类型（按顺序）
方法的修饰符（public,private,protected,static,final,synchronized,native,abstract 的某个子集）
方法的字节码（bytecodes）、操作数栈、局部变量表及大小（native,abstract 方法除外）
异常表（native,abstract 方法除外）
- 每个异常处理的开始位置、结束位置、代码处理在程序计数器中的偏移位置、被捕获的异常类的常量池索引

代码举例

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;
    }
    public int compareTo(String o){
        return 0;
    }

}

反编译成字节码文件：

Classfile /D:/web/IdeaProjects/chunzhao/out/production/chunzhao/learn/jvm/simple/methodspace/MethodInnerStrucTest.class
  Last modified 2020年5月18日; size 1645 bytes
  MD5 checksum 84a7241e48ee222b3cae4dc29b7c001a
  Compiled from "MethodInnerStrucTest.java"
  //类型信息
public class learn.jvm.simple.methodspace.MethodInnerStrucTest extends java.lang.Object implements java.lang.Comparable<java.lang.String>, java.io.Serializable
  minor version: 0
  major version: 52
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #17                         // learn/jvm/simple/methodspace/MethodInnerStrucTest
  super_class: #18                        // java/lang/Object
  interfaces: 2, fields: 2, methods: 6, attributes: 2
Constant pool:
   #1 = Methodref          #18.#51        // java/lang/Object."<init>":()V
   #2 = Fieldref           #17.#52        // learn/jvm/simple/methodspace/MethodInnerStrucTest.num:I
   #3 = Fieldref           #53.#54        // java/lang/System.out:Ljava/io/PrintStream;
   #4 = Class              #55            // java/lang/StringBuilder
   #5 = Methodref          #4.#51         // java/lang/StringBuilder."<init>":()V
   #6 = String             #56            // count=
   #7 = Methodref          #4.#57         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   #8 = Methodref          #4.#58         // java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
   #9 = Methodref          #4.#59         // java/lang/StringBuilder.toString:()Ljava/lang/String;
  #10 = Methodref          #60.#61        // java/io/PrintStream.println:(Ljava/lang/String;)V
  #11 = Class              #62            // java/lang/Exception
  #12 = Methodref          #11.#63        // java/lang/Exception.printStackTrace:()V
  #13 = Class              #64            // java/lang/String
  #14 = Methodref          #17.#65        // learn/jvm/simple/methodspace/MethodInnerStrucTest.compareTo:(Ljava/lang/String;)I
  #15 = String             #66            // 测试方法的内部结构
  #16 = Fieldref           #17.#67        // learn/jvm/simple/methodspace/MethodInnerStrucTest.str:Ljava/lang/String;
  #17 = Class              #68            // learn/jvm/simple/methodspace/MethodInnerStrucTest
  #18 = Class              #69            // java/lang/Object
  #19 = Class              #70            // java/lang/Comparable
  #20 = Class              #71            // 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               Llearn/jvm/simple/methodspace/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 = Utf8               compareTo
  #43 = Utf8               (Ljava/lang/String;)I
  #44 = Utf8               o
  #45 = Utf8               (Ljava/lang/Object;)I
  #46 = Utf8               <clinit>
  #47 = Utf8               Signature
  #48 = Utf8               Ljava/lang/Object;Ljava/lang/Comparable<Ljava/lang/String;>;Ljava/io/Serializable;
  #49 = Utf8               SourceFile
  #50 = Utf8               MethodInnerStrucTest.java
  #51 = NameAndType        #25:#26        // "<init>":()V
  #52 = NameAndType        #21:#22        // num:I
  #53 = Class              #72            // java/lang/System
  #54 = NameAndType        #73:#74        // out:Ljava/io/PrintStream;
  #55 = Utf8               java/lang/StringBuilder
  #56 = Utf8               count=
  #57 = NameAndType        #75:#76        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #58 = NameAndType        #75:#77        // append:(I)Ljava/lang/StringBuilder;
  #59 = NameAndType        #78:#79        // toString:()Ljava/lang/String;
  #60 = Class              #80            // java/io/PrintStream
  #61 = NameAndType        #81:#82        // println:(Ljava/lang/String;)V
  #62 = Utf8               java/lang/Exception
  #63 = NameAndType        #83:#26        // printStackTrace:()V
  #64 = Utf8               java/lang/String
  #65 = NameAndType        #42:#43        // compareTo:(Ljava/lang/String;)I
  #66 = Utf8               测试方法的内部结构
  #67 = NameAndType        #23:#24        // str:Ljava/lang/String;
  #68 = Utf8               learn/jvm/simple/methodspace/MethodInnerStrucTest
  #69 = Utf8               java/lang/Object
  #70 = Utf8               java/lang/Comparable
  #71 = Utf8               java/io/Serializable
  #72 = Utf8               java/lang/System
  #73 = Utf8               out
  #74 = Utf8               Ljava/io/PrintStream;
  #75 = Utf8               append
  #76 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #77 = Utf8               (I)Ljava/lang/StringBuilder;
  #78 = Utf8               toString
  #79 = Utf8               ()Ljava/lang/String;
  #80 = Utf8               java/io/PrintStream
  #81 = Utf8               println
  #82 = Utf8               (Ljava/lang/String;)V
  #83 = Utf8               printStackTrace
{
    //域信息
  public int num;
    descriptor: I
    flags: (0x0001) ACC_PUBLIC

  private static java.lang.String str;
    descriptor: Ljava/lang/String;
    flags: (0x000a) ACC_PRIVATE, ACC_STATIC
  //方法：<init>
  public learn.jvm.simple.methodspace.MethodInnerStrucTest();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: bipush        10
         7: putfield      #2                  // Field num:I
        10: return
      LineNumberTable:
        line 5: 0
        line 7: 4
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      11     0  this   Llearn/jvm/simple/methodspace/MethodInnerStrucTest;

  public void test1();
    //返回类型
    descriptor: ()V
    //修饰符
    flags: (0x0001) ACC_PUBLIC
    Code:
        //操作数栈的深度3，局部变量表长度2，参数大小1（this）
      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 12: 0
        line 13: 3
        line 14: 28
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      29     0  this   Llearn/jvm/simple/methodspace/MethodInnerStrucTest;
            3      26     1 count   I

  public static int test2(int);
    descriptor: (I)I
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=3, args_size=1
         0: iconst_0
         1: istore_1
         2: bipush        30
         4: istore_2
         5: iload_2
         6: iload_0
         7: idiv
         8: istore_1
         9: goto          17
        12: astore_2
        13: aload_2
        14: invokevirtual #12                 // Method java/lang/Exception.printStackTrace:()V
        17: iload_1
        18: ireturn
      Exception table:
         from    to  target type
             2     9    12   Class java/lang/Exception
      LineNumberTable:
        line 16: 0
        line 18: 2
        line 19: 5
        line 22: 9
        line 20: 12
        line 21: 13
        line 23: 17
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            5       4     2 value   I
           13       4     2     e   Ljava/lang/Exception;
            0      19     0   cal   I
            2      17     1 result   I
      StackMapTable: number_of_entries = 2
        frame_type = 255 /* full_frame */
          offset_delta = 12
          locals = [ int, int ]
          stack = [ class java/lang/Exception ]
        frame_type = 4 /* same */

  public int compareTo(java.lang.String);
    descriptor: (Ljava/lang/String;)I
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=2, args_size=2
         0: iconst_0
         1: ireturn
      LineNumberTable:
        line 26: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       2     0  this   Llearn/jvm/simple/methodspace/MethodInnerStrucTest;
            0       2     1     o   Ljava/lang/String;

  public int compareTo(java.lang.Object);
    descriptor: (Ljava/lang/Object;)I
    flags: (0x1041) ACC_PUBLIC, ACC_BRIDGE, ACC_SYNTHETIC
    Code:
      stack=2, locals=2, args_size=2
         0: aload_0
         1: aload_1
         2: checkcast     #13                 // class java/lang/String
         5: invokevirtual #14                 // Method compareTo:(Ljava/lang/String;)I
         8: ireturn
      LineNumberTable:
        line 5: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  this   Llearn/jvm/simple/methodspace/MethodInnerStrucTest;

  static {};
    descriptor: ()V
    flags: (0x0008) ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: ldc           #15                 // String 测试方法的内部结构
         2: putstatic     #16                 // Field str:Ljava/lang/String;
         5: return
      LineNumberTable:
        line 8: 0
}
Signature: #48                          // Ljava/lang/Object;Ljava/lang/Comparable<Ljava/lang/String;>;Ljava/io/Serializable;
SourceFile: "MethodInnerStrucTest.java"

non-final的类变量

静态变量和类关联在一起，随着类的加载而加载，它们成为类数据在逻辑上的一部分。
类变量被类的所有实例共享，即使没有类实例你也可以访问它。

全局常量static final

每个全局常量在编译的时候就被分配了。

public static int count = 1;
public static final int number = 2;

对于

public static int count;
    descriptor: I
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC

  public static final int number;
    descriptor: I
    flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL
    ConstantValue: int 2  //已经分配值了

常量池

一个java源文件中的类、接口，编译后产生一个字节码文件。而java中的字节码需要数据支持，通常这种数据会很大以至于不能直接存到字节码里，换一种方式，可以存到常量池，这个字节码里包含了指向常量池的引用。在动态链接的时候会用到运行时常量池。

常量池中存储的数据类型包括：

数量值
字符串值
类引用
字段引用
方法引用

public class MethodAreaTestSimple {
    public static void main(String[] args) {
        Object obj = new Object();
    }
}

编译成：

//常量池
Constant pool:
   #1 = Methodref          #2.#19         // java/lang/Object."<init>":()V
   #2 = Class              #20            // java/lang/Object
   #3 = Class              #21            // learn/jvm/simple/methodspace/MethodAreaTestSimple
   #4 = Utf8               <init>
   ……
  #21 = Utf8               learn/jvm/simple/methodspace/MethodAreaTestSimple
......
//main方法
public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: new           #2                  // class java/lang/Object
         3: dup
         4: invokespecial #1                  // Method java/lang/Object."<init>":()V
         7: astore_1
         8: return
      LineNumberTable:
        line 5: 0
        line 6: 8
      LocalVariableTable:
        ……
}

常量池可以看做是一张表，虚拟机指令根据这张表找到要执行的类名、方法名、参数类型、字面量等类型

运行时常量池

运行时常量池是方法区的一部分。
常量池表是Class文件的一部分，用于存放编译器生成的各种字面量与符号引用，这部分内容将在类加载后存放到方法区的运行时常量池中。
运行时常量池，在加载类和接口到虚拟机后，就会创建对应的运行时常量池。
JVM为每个已加载的类型（类或接口）都维护一个常量池。池中的数据项像数组项一样，是通过索引访问的。
运行时常量池中包含多种不同的变量，包括编译期就已经明确的数值字面量，也包括到运行期解析后才能够获得的方法或者字段引用。此时就不再是常量池中的符号地址了，这里换为真实地址。
- 运行时常量池，相对于Class文件常量池的零一特征是：具备动态性。
运行时常量池类似于传统编程语言中的符号表，但是它所包含的数据却比符号表要更加丰富一些。
当创建类或接口的运行时常量池时，如果构造运行时常量池所需的内存空间超过了方法区所能提供的最大值，则JVM会抛OOME异常。

5. 方法区使用举例

java文件

public class MethodAreaDemo2 {
    public static void main(String[] args) {
        int x = 500;
        int y = 100;
        int a = x/y;
        int b = 50;
        System.out.println(a + b);
    }
}

程序入口：main方法

 序号	字节码指令
0: sipush        500   //将500压入操作数栈
3: istore_1		//弹出操作数栈顶的500，存入本地变量表1
4: bipush        100   //将100压入操作数栈
6: istore_2		//弹出操作数栈顶的100，存入本地变量表2
7: iload_1		//将本地变量表1压入操作数栈
8: iload_2		//将本地变量表2压入操作数栈
9: idiv		//将栈顶两int类型相除，结果5入栈
10: istore_3	//弹出操作数栈顶的5，存入本地变量表3
11: bipush        50  //将50压入操作数栈
13: istore        4  //将操作数栈顶int值，存入本地变量表4
15: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream; 把#2：System.out压入操作数栈
	#2 = Fieldref           #25.#26        // java/lang/System.out:Ljava/io/PrintStream;
	#25 = Class              #31            // java/lang/System
  	#26 = NameAndType        #32:#33        // out:Ljava/io/PrintStream;
  	#31 = Utf8               java/lang/System
  	#32 = Utf8          out
  	#33 = Utf8          Ljava/io/PrintStream;
18: iload_3		//将本地变量表3压入操作数栈 [#2 5|
19: iload         4//将本地变量表4压入操作数栈 [#2 5 50|
21: iadd	//将栈顶两int类型相加，结果55入栈 [#2 55|
22: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V ; 调用println方法
	#3 = Methodref          #27.#28        // java/io/PrintStream.println:(I)V
   	#27 = Class              #34            // java/io/PrintStream
  	#28 = NameAndType        #35:#36        // println:(I)V
  	#34 = Utf8               java/io/PrintStream
  	#35 = Utf8               println  //方法名
  	#36 = Utf8               (I)V	  //返回类型
25: return

6. 方法区的演进细节

首先，只有Hotspot才有永久代
Hotspot中方法区的变化：

版本	描述
jdk6及之前	有永久代，静态变量存放在永久代上
jdk7	有永久代，但已经逐步“去永久代”，字符串常量池、静态变量移除，保存在堆中
jdk8	无永久代，类型信息、字段、方法、常量保存在本地内存的元空间，但字符串常量池、静态变量仍在堆

在这里插入图片描述

永久代为什么要被元空间替代？

官方：JRockit和Hotspot融合

为永久代设置空间大小是很难确定的
如果动态加载类过多，容易OOM。
默认情况下，元空间的大小仅受本地内存限制
对永久代进行调优是很困难的

StringTable为什么要调整？

java7将StringTable放到了堆空间中。因为永久代的回收效率很低，在full gc的时候才会触发。而full gc是老年代空间不足、永久代不足时才会触发。

这导致StringTable的回收效率不高。而开发中会有大量的字符串被创建，回收效率低，导致永久代内存不足，放到堆里，能及时回收内存。

静态变量放在哪里？

堆
只要是对象实例必然会在java堆中分配。

7. 方法区的垃圾收集

《Java虚拟机规范》中，可以不要求虚拟机在方法区中实现垃圾收集。

一般来说这个区域的回收效果比较难让人满意，尤其是类型的卸载，条件相当苛刻。但是这部分区域的回收又确实是有必要的。（以前Sun公司的Bug列表中，曾出现的若干个严重的bug就是由于低版本的Hotspot虚拟机对此区域未完全回收而导致内存泄漏。

方法区的垃圾收集主要回收两部分：常量池中废弃的常量和不再使用的类型。

判断一个常量是否“废弃”相对简单，而要判定一个类型是否属于“不再被使用”的条件就比较苛刻了，需要同时满足下面三个条件：
- 该类的所有实例都已经被回收，也就是java堆中不存在该类及其任何派生子类的实例。
- 加载该类的类加载器已经被回收，这个条件除非是经过精心设计的可替换类加载器的场景，如OSCI，JSP的重加载等，否则通常是很难达成的。
- 该类对应的java.lang.Class对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。
Java虚拟机被允许对满足上述三个条件的无用类进行回收，这里仅仅是“被允许”，而不是和对象一样，没有引用了就必然会回收。关于是否需要对类型进行回收，Hotspot虚拟机提供了-Xnoclassgc参数进行控制，还可以使用-verbose:class以及-XX:+TraceClass-Loading、-XX:TraceClassUnLoading查看类加载和卸载信息
在大量使用反射、动态代理、CGLib等字节码框架，动态生成JSP以及OSGi这类频繁在自定义类加载器的场景中，*通常需要Java虚拟机具备类型卸载的能力，以保证不会对方法区造成过大的内存压力 *。

《尚硅谷2020最新版宋红康JVM教程》P87-100