聊聊jvm的内存结构, 以及各种结构的作用

什么是JVM

界说：Java Virtual Machine，JAVA程序的运行环境（JAVA二进制字节码的运行环境）

内存结构

JVM 内存布局规定了 Java 在运行过程中内存申请、分配、管理的计谋，保证了 JVM 的高效稳固运行。不同的 JVM 对于内存的划分方式和管理机制存在着部分差异。这也就是常说的运行时数据区

程序计数器

界说

线程私有的，作为当火线程的行号指示器，用于记录当前假造机正在执行的线程指令地点。
作用

• 当火线程所执行的字节码的行号指示器，通过它实当代码的流程控制，如：顺序执行、选择、循环、异常处理。
  
• 在多线程的情况下，程序计数器用于记录当火线程执行的位置，当线程被切换回来的时间能够知道它上次执行的位置。
  

特点

• 线程私有
  
• CPU会为每个线程分配时间片，当当火线程的时间片使用完以后，CPU就会去执行另一个线程中的代码
  
• 程序计数器是每个线程所私有的，当另一个线程的时间片用完，又返回来执行当火线程的代码时，通过程序计数器可以知道应该执行哪一句指令
  
• 不会存在内存溢出
  

程序计数器是唯一一个不会出现 OutOfMemoryError 的内存区域，它的生命周期随着线程的创建而创建，随着线程的结束而殒命
假造机栈

概述

界说：每个线程在创建的时间都会创建一个假造机栈，其内部生存一个个的栈帧(Stack Frame），对应着一次次 Java 方法调用，是线程私有的，生命周期和线程同等。
作用：主管 Java 程序的运行，它生存方法的局部变量、部分结果，并参与方法的调用和返回。
特点：

• 每个线程运行需要的内存空间，称为假造机栈。是线程私有的，每个线程都有各自的 Java 假造机栈，而且随着线程的创建而创建，随着线程的殒命而殒命
  
• Java 假造机栈是由一个个栈帧组成，对应着每次调用方法时所占用的内存。每一次函数调用都会有一个对应的栈帧被压入假造机栈，每一个函数调用结束后，都会有一个栈帧被弹出。两种返回函数的方式，不管用哪种方式，都会导致栈帧被弹出
  
  
  
  • 正常的函数返回，使用 return 指令
    
  • 抛出异常
    
  
  
• 每个线程只能有一个活动栈帧，栈顶存放当前当前正在执行的方法
  

栈中内部结构

每个栈帧中都存储着：

• 局部变量表（Local Variables）
  
• 操作数栈（Operand Stack）(或称为表达式栈)
  
• 动态链接（Dynamic Linking）：指向运行时常量池的方法引用
  
• 方法返回地点（Return Address）：方法正常退出或异常退出的地点
  

局部变量表

存放了编译期可知的各种根本范例(boolean、byte、char、short、int、float、long、double)、对象引用(reference 范例)和 returnAddress 范例(指向了一条字节码指令的地点)。（Java的根本数据范例不一定存放在栈中，局部变量的根本范例存放在栈中，引用范例的变量名存放在栈中，但是变量名所指向的对象（根本数据范例）存放在堆中。而成员变量，不管是根本范例照旧引用范例，变量名和对象都放在堆中。）
由于局部变量表是创建在线程的栈上，是线程的私有数据，因此不存在数据安全问题
操作数栈

是一个后进先出（Last-In-First-Out）的操作数栈，也可以称为表达式栈（Expression Stack）。主要用于生存计算过程的中心结果，同时作为计算过程中变量临时的存储空间
操作数栈，在方法执行过程中，根据字节码指令，往操作数栈中写入数据或提取数据，即入栈（push）、出栈（pop）。某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈。使用它们后再把结果压入栈。好比，执行复制、互换、求和等操作
动态链接

每个栈帧都包罗一个指向运行时常量池中该栈所属方法的符号引用，在方法调用过程中，会进行动态链接，将这个符号引用转化为直接引用。

• 部分符号引用在类加载阶段的时间就转化为直接引用，这种转化就是静态链接
  
• 部分符号引用在运行期间转化为直接引用，这种转化就是动态链接
  

方法返回地点

用来存放调用该方法的 PC 寄存器的值。
一个方法的结束，有两种方式

• 正常执行完成
  
• 出现未处理的异常，非正常退出
  

无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置。方法正常退出时，调用者的 PC 计数器的值作为返回地点，即调用该方法的指令的下一条指令的地点。而通过异常退出的，返回地点是要通过异常表来确定的，栈帧中一般不会生存这部分信息。
本质上，方法的退出就是当前栈帧出栈的过程。此时，需要规复上层方法的局部变量表、操作数栈、将返回值压入调用者栈帧的操作数栈、设置PC寄存器值等，让调用者方法继续执行下去。
正常完成出口和异常完成出口的区别在于：通过异常完成出口退出的不会给他的上层调用者产生任何的返回
假造机栈的错误

Java 假造机栈会出现两种错误：StackOverFlowError 和 OutOfMemoryError 。可以通过 -Xss 参数来指定每个线程的假造机栈内存巨细：

1. java -Xss2M

复制代码

stackOverflowError发生原因

• 假造机栈中，栈帧过多（无限递归）
  
• 每个栈帧所占用内存过大
  

OutOfMemoryError发生原因

• 在单线程程序中，无法出现OOM异常；但是通过循环创建线程（线程体调用方法），可以产生OOM异常。此时OOM异常产生的原因与栈空间是否足够大无关。
  
• 线程动态扩展，没有足够的内存供申请时会产生OOM
  

问题辨析

• 垃圾回收是否涉及栈内存？
  
  
  
  • 不需要。因为假造机栈中是由一个个栈帧组成的，在方法执行完毕后，对应的栈帧就会被弹出栈。所以无需通过垃圾回收机制去回收内存。
    
  
  
• 栈内存的分配越大越好吗？
  
  
  
  • 不是。因为物理内存是一定的，栈内存越大，可以支持更多的递归调用，但是可执行的线程数就会越少。
    
  
  
• 方法内的局部变量是否是线程安全的？
  
  
  
  • 如果方法内局部变量没有逃离方法的作用范围，则是线程安全的；如果如果局部变量引用了对象，并逃离了方法的作用范围，则需要考虑线程安全问题
    
  
  

线程运行诊断

CPU占用过高

• Linux环境下运行某些程序的时间，可能导致CPU的占用过高，这时需要定位占用CPU过高的线程
  
• top命令，查看是哪个进程占用CPU过高
  
• ps H -eo pid, tid（线程id）, %cpu | grep 刚才通过top查到的进程号 通过ps命令进一步查看是哪个线程占用CPU过高
  
• jstack 进程id 通过查看进程中的线程的nid，刚才通过ps命令看到的tid来对比定位，注意jstack查找出的线程id是16进制的，需要转换
  

当地方法栈

也是线程私有的
假造机栈为假造机执行 Java 方法服务，而当地方法栈则为假造机使用到的 Native 方法服务。Native 方法一般是用其它语言（C、C++等）编写的。
当地方法被执行的时间，在当地方法栈也会创建一个栈帧，用于存放该当地方法的局部变量表、操作数栈、动态链接、出口信息。
使用当地方法的原因：一些带有native关键字的方法就是需要JAVA去调用C或者C++方法，因为JAVA有时间没法直接和操作系统底层交互，所以需要用到当地方法
Native Method Stack：它的具体做法是Native Method Stack中登记native方法，在( Execution Engine )执行引擎执行的时间加载Native Libraies
Native Interface当地接口：当地接口的作用是融合不同的编程语言为Java所用，它的初衷是融合C/C程序, Java在诞生的时间是C/C横行的时间，想要立足，必须有调用C、C++的程序，于是就在内存中专门开发了块区域处理标志为native的代码，它的具体做法是在Native Method Stack 中登记native方法,在( Execution Engine )执行引擎执行的时间加载Native Libraies。  目前该方法使用的越来越少了，除非是与硬件有关的应用，好比通过Java程序驱动打印机或者Java系统管理生产设备，在企业级应用中已经比较少见。因为现在的异构领域间通讯很发达，好比可以使用Socket通讯,也可以使用Web Service等等
在 Hotspot JVM 中，直接将当地方法栈和假造机栈合二为一
当地方法栈出现异常同假造机栈
堆

界说

通过new关键字创建的对象都会被放在堆内存
特点

• 所有线程共享，堆内存中的对象都需要考虑线程安全问题
  
• 有垃圾回收机制
  
• 堆中的区域：新生代（ Eden 空间、 From Survivor 、 To Survivor 空间）和老年代。
  

年轻代被分为三个部分——伊甸园（Eden Memory）和两个幸存区（Survivor Memory，被称为from/to或s0/s1），默认比例是8:1:1
通过 -Xms 设定程序启动时占用内存巨细，通过 -Xmx 设定程序运行期间最大可占用的内存巨细。如果程序运行需要占用更多的内存，超出了这个设置值，就会抛出 OutOfMemory 异常。

1. -Xms1M -Xmx2M

复制代码

伊甸园区是对象创建的区域，但是伊甸园区如果满了的话会调用轻GC进行垃圾回收，如果此时对象被引用就会幸存下来进入到幸存区，此时伊甸园区的内存清空，垃圾被回收。如果说幸存区也满了的话就会进入老年区。
GC垃圾回收主要是在伊甸园区和老年区。
设置堆内存巨细和 OOM

Java 堆用于存储 Java 对象实例，那么堆的巨细在 JVM 启动的时间就确定了，我们可以通过 -Xmx 和 -Xms 来设定

• -Xms 用来表示堆的起始内存，等价于 -XX:InitialHeapSize
  
• -Xmx 用来表示堆的最大内存，等价于 -XX:MaxHeapSize
  

如果堆的内存巨细凌驾 -Xmx 设定的最大内存， 就会抛出 OutOfMemoryError 异常。
我们通常会将 -Xmx 和 -Xms 两个参数配置为雷同的值，其目标是为了能够在垃圾回收机制清算完堆区后不再需要重新分隔计算堆的巨细，从而提高性能。如果 -Xms 和 -Xmx 设置为不同的值，JVM 在运行时可能会根据内存使用情况不停调整堆的巨细。这种动态调整需要进行内存分配和垃圾收集，可能会增长系统的开销和延长。而将这两个参数设置为雷同的值，JVM 在启动时就分配好固定量的堆内存，从而避免了内存重新分配的开销。

• 默认情况下，初始堆内存巨细为：电脑内存巨细/64
  
• 默认情况下，最大堆内存巨细为：电脑内存巨细/4
  

可以通过代码获取到设置值，当然也可以模仿 OOM：
OOM就是在连老年区都溢出了之后，整个内存已经无法承受，就会报出堆内存溢出的错误。也就是java.lang.OutofMemoryError ：java heap space. 堆内存溢出。

1. public static void main(String[] args) {
3.   //返回 JVM 堆大小
4.   long initalMemory = Runtime.getRuntime().totalMemory() / 1024 /1024;
5.   //返回 JVM 堆的最大内存
6.   long maxMemory = Runtime.getRuntime().maxMemory() / 1024 /1024;
7.     //freeMemory 获取当前程序拿到的内存中，还没用上的，即是可以被 gc 回收的。
8.    
9.   System.out.println("-Xms : "+initalMemory + "M");
10.   System.out.println("-Xmx : "+maxMemory + "M");
12.   System.out.println("系统内存大小：" + initalMemory * 64 / 1024 + "G");
13.   System.out.println("系统内存大小：" + maxMemory * 4 / 1024 + "G");
14. }

复制代码

查看 JVM 堆内存分配

• 在默认不配置 JVM 堆内存巨细的情况下，JVM 根据默认值来配置当前内存巨细
  
• 默认情况下新生代和老年代的比例是 1:2，可以通过 –XX:NewRatio 来配置
  
  
  
  • 新生代中的 EdenFrom SurvivorTo Survivor的比例是8:1:1，可以通过-XX:SurvivorRatio来配置
    
  
  
• JDK 8 默认开启-XX:+UseAdaptiveSizePolicy，不要随意关闭-XX:+UseAdaptiveSizePolicy，除非对堆内存的划分有明确的规划
  
• 每次 GC 后都会重新计算 Eden、From Survivor、To Survivor 的巨细
  

计算依据是GC过程中统计的GC时间、吞吐量、内存占用量

1. java -XX:+PrintFlagsFinal -version | grep HeapSize
2.     uintx ErgoHeapSizeLimit                         = 0                                   {product}
3.     uintx HeapSizePerGCThread                       = 87241520                            {product}
4.     uintx InitialHeapSize                          := 134217728                           {product}
5.     uintx LargePageHeapSizeThreshold                = 134217728                           {product}
6.     uintx MaxHeapSize                              := 2147483648                          {product}
7. java version "1.8.0_211"
8. Java(TM) SE Runtime Environment (build 1.8.0_211-b12)
9. Java HotSpot(TM) 64-Bit Server VM (build 25.211-b12, mixed mode)

复制代码

1. $ jmap -heap 进程号

复制代码

方法区

结构

方法区与 Java 堆一样，是各个线程共享的内存区域，它用于存储已被假造机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
对方法区进行垃圾回收的主要目标是对常量池的回收和对类的卸载。
方法区（method area）只是 JVM 规范中界说的一个概念，用于存储类信息、常量池、静态变量、JIT编译后的代码等数据，并没有规定怎样去实现它，不同的厂商有不同的实现。而永世代（PermGen）是 Hotspot 假造机特有的概念， Java8 的时间又被元空间代替了，永世代和元空间都可以明白为方法区的落地实现。
永世代和元空间

永世代

方法区是 JVM 的规范，而永世代 PermGen 是方法区的一种实现方式，并且只有 HotSpot 有永世代。对于其他范例的假造机，如 JRockit 没有永世代。由于方法区主要存储类的相关信息，所以对于动态生成类的场景比较容易出现永世代的内存溢出。
永世区是常驻内存的，是用来存放JDK自身携带的Class对象和interface元数据。这样这些数据就不会占用空间。用于存储java运行时环境。

• 在JDK1.7前，字符串存放在方法区之中
  
• 在JDK1.7后字符串被放在了堆
  
• 在Java8，取消了方法区，改用了直接使用直接内存的的元空间。即元空间逻辑上属于堆，但在物理内存上，元空间的内存并不由堆空间内存分配
  

元空间

JDK 1.8 的时间， HotSpot 的永世代被彻底移除了，使用元空间替代。元空间的本质和永世代类似，都是对JVM规范中方法区的实现。两者最大的区别在于：元空间并不在假造机中，而是使用直接内存。

为什么要将永世代替换为元空间呢？永世代内存受限于 JVM 可用内存，而元空间使用的是直接内存，受本机可用内存的限制，固然元空间仍旧可能溢出，但是相比永世代内存溢出的概率更小。

内部结构

方法区用于存储已被假造机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
范例信息

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

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

域（Field）信息

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

方法（Method）信息

JVM 必须生存所有方法的

• 方法名称
  
• 方法的返回范例
  
• 方法参数的数量和范例
  
• 方法的修饰符（public，private，protected，static，final，synchronized，native，abstract 的一个子集）
  
• 方法的字符码（bytecodes）、操作数栈、局部变量表及巨细（abstract 和 native 方法除外）
  
• 异常表（abstract 和 native 方法除外）
  
  
  
  • 每个异常处理的开始位置、结束位置、代码处理在程序计数器中的偏移地点、被捕获的异常类的常量池索引
    
  
  

运行时常量池

运行时常量池（Runtime Constant Pool）是方法区的一部分）
常量池

一个有效的字节码文件中除了包罗类的版本信息、字段、方法以及接口等描述信息外，还包罗一项信息那就是常量池表（Constant Pool Table），包罗各种字面量和对范例、域和方法的符号引用。
为什么需要常量池？
一个 Java 源文件中的类、接口，编译后产生一个字节码文件。而 Java 中的字节码需要数据支持，通常这种数据会很大以至于不能直接存到字节码里，换另一种方式，可以存到常量池，这个字节码包罗了指向常量池的引用。在动态链接的时间用到的就是运行时常量池。
如下，我们通过 jclasslib 查看一个只有 Main 方法的简单类，字节码中的 #2 指向的就是 Constant Pool

常量池可以看作是一张表，假造机指令根据这张常量表找到要执行的类名、方法名、参数范例、字面量等范例。
运行时常量池

• 在加载类和结构到假造机后，就会创建对应的运行时常量池
  
• 常量池表（Constant Pool Table）是 Class 文件的一部分，用于存储编译期生成的各种字面量和符号引用，这部分内容将在类加载后存放到方法区的运行时常量池中
  
• JVM 为每个已加载的范例（类或接口）都维护一个常量池。池中的数据项像数组项一样，是通过索引访问的
  
• 运行时常量池中包罗各种不同的常量，包括编译器就已经明确的数值字面量，也包括到运行期剖析后才气够得到的方法或字段引用。此时不再是常量池中的符号地点了，这里换为真实地点
  
  
  
  • 运行时常量池，相对于 Class 文件常量池的另一个重要特征是：动态性，Java 语言并不要求常量一定只有编译期间才气产生，运行期间也可以将新的常量放入池中，String 类的intern()方法就是这样的
    
  
  
• 当创建类或接口的运行时常量池时，如果构造运行时常量池所需的内存空间凌驾了方法区所能提供的最大值，则 JVM 会抛出 OutOfMemoryError 异常
  

字符串进入串池案例

字符串赋值：

1. public static void main(String[] args) {
2.         String a = "a";
3.         String b = "b";
4.         String ab = "ab";
5.     }

复制代码

常量池中的信息，都会被加载到运行时常量池中，但这时a b ab 仅是常量池中的符号，还没有成为java字符串

1. 0: ldc           #2                  // String a
2. 2: astore_1
3. 3: ldc           #3                  // String b
4. 5: astore_2
5. 6: ldc           #4                  // String ab
6. 8: astore_3
7. 9: return

复制代码

当执行到 ldc #2 时，会把符号 a 变为 “a” 字符串对象，并放入串池中
当执行到 ldc #3 时，会把符号 b 变为 “b” 字符串对象，并放入串池中
当执行到 ldc #4 时，会把符号 ab 变为 “ab” 字符串对象，并放入串池中
最终StringTable [“a”, “b”, “ab”]
注意：字符串对象的创建都是懒惰的，只有当运行到那一行字符串且在串池中不存在的时间（如 ldc #2）时，该字符串才会被创建并放入串池中。

• 使用拼接字符串变量对象创建字符串的过程：
  

1. public class StringTableStudy {
2.     public static void main(String[] args) {
3.         String a = "a";
4.         String b = "b";
5.         String ab = "ab";
6.         //拼接字符串对象来创建新的字符串
7.         String ab2 = a+b; //实际StringBuilder拼接形成
8.     }
9. }

复制代码

反编译后的结果

1. Code:
2.       stack=2, locals=5, args_size=1
3.          0: ldc           #2                  // String a
4.          2: astore_1
5.          3: ldc           #3                  // String b
6.          5: astore_2
7.          6: ldc           #4                  // String ab
8.          8: astore_3
9.          9: new           #5                  // class java/lang/StringBuilder
10.         12: dup
11.         13: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
12.         16: aload_1
13.         17: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
14.         20: aload_2
15.         21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
16.         24: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
17.         27: astore        4
18.         29: return

复制代码

通过拼接的方式来创建字符串的过程是：StringBuilder().append(“a”).append(“b”).toString()最后的toString方法的返回值是一个新的字符串，固然字符串的值和拼接的字符串同等，但是两个不同的字符串，一个存在于串池之中，一个存在于堆内存之中

1. String ab = "ab";
2. String ab2 = a+b;
3. //结果为false,因为ab是存在于串池之中，ab2是由StringBuilder的toString方法所返回的一个对象，存在于堆内存之中
4. System.out.println(ab == ab2);

复制代码

• 使用拼接字符串常量对象的方法创建字符串
  

1. public class StringTableStudy {
2.     public static void main(String[] args) {
3.         String a = "a";
4.         String b = "b";
5.         String ab = "ab";
6.         String ab2 = a+b;
7.         
8.     //使用拼接字符串常量的方法创建字符串
9.         String ab3 = "a" + "b";//ab3直接从串池中获取值,相当于ab3="ab"
10.     }
11. }

复制代码

反编译后的结果

1. Code:
2.       stack=2, locals=6, args_size=1
3.          0: ldc           #2                  // String a
4.          2: astore_1
5.          3: ldc           #3                  // String b
6.          5: astore_2
7.          6: ldc           #4                  // String ab
8.          8: astore_3
9.          9: new           #5                  // class java/lang/StringBuilder
10.         12: dup
11.         13: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
12.         16: aload_1
13.         17: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
14.         20: aload_2
15.         21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
16.         24: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
17.         27: astore        4
18.         //ab3初始化时直接从串池中获取字符串
19.         29: ldc           #4                  // String ab
20.         31: astore        5
21.         33: return

复制代码

使用拼接字符串常量的方法来创建新的字符串时，因为内容是常量，javac在编译期会进行优化，结果已在编译期确定为ab，而创建ab的时间已经在串池中放入了“ab”，所以ab3直接从串池中获取值，所以进行的操作和 ab = “ab” 同等。
使用拼接字符串变量的方法来创建新的字符串时，因为内容是变量，只能在运行期确定它的值，所以需要使用StringBuilder来创建

• intern方法 1.8
  

调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中

• 如果串池中没有该字符串对象，则放入成功
  
• 如果有该字符串对象，则放入失败
  

无论放入是否成功，都会返回串池中的字符串对象
注意：此时如果调用intern方法成功，堆内存与串池中的字符串对象是同一个对象；如果失败，则不是同一个对象
例1：

1. public class Main {
2.     public static void main(String[] args) {
3.         //"a" "b" 被放入串池中，str则存在于堆内存之中
4.         String str = new String("a") + new String("b");
5.         //调用str的intern方法，这时串池中没有"ab"，则会将该字符串对象放入到串池中，此时堆内存与串池中的"ab"是同一个对象
6.         String st2 = str.intern();
7.         //给str3赋值，因为此时串池中已有"ab"，则直接将串池中的内容返回
8.         String str3 = "ab";
9.         //因为堆内存与串池中的"ab"是同一个对象，所以以下两条语句打印的都为true
10.         System.out.println(str == st2);
11.         System.out.println(str == str3);
12.     }
13. }

复制代码

例2：

1. public class Main {
2.     public static void main(String[] args) {
3.         //此处创建字符串对象"ab"，因为串池中还没有"ab"，所以将其放入串池中
4.         String str3 = "ab";
5.         //"a" "b" 被放入串池中，str则存在于堆内存之中
6.         String str = new String("a") + new String("b");
7.         //此时因为在创建str3时，"ab"已存在于串池中，所以放入失败，但是会返回串池中的"ab"
8.         String str2 = str.intern();
9.         //false，str在堆内存，str2在串池
10.         System.out.println(str == str2);
11.         //false，str在堆内存，str3在串池
12.         System.out.println(str == str3);
13.         //true，str2和str3是串池中的同一个对象
14.         System.out.println(str2 == str3);
15.     }
16. }

复制代码

方法区的垃圾回收

方法区的垃圾回收主要有两种，分别是对废弃常量的回收和对无用类的回收。

• 当一个常量对象不再任何地方被引用的时间，则被标志为废弃常量，这个常量可以被回收。
  
• 无用类:
  
  
  
  • 该类所有的实例都已经被回收。
    
  • 加载该类的类加载器已经被回收。这个条件除非是颠末经心设计的可替换类加载器的场景，如 OSGi、JSP 的重加载等，否则通常很难达成
    
  • 该类对应的 java.lang.Class 对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。
    
  
  

假造机可以对满意上述 3 个条件的类进行回收，但不一定会进行回收。是否对类进行回收，HotSpot 假造机提供了 -Xnoclassgc 参数进行控制，还可以使用 -verbose:class 以及 -XX:+TraceClassLoading 、-XX:+TraceClassUnLoading 查看类加载和卸载信息。
在大量使用反射、动态代理、CGLib 等 ByteCode 框架、动态生成 JSP 以及 OSGi 这类频繁自界说 ClassLoader 的场景都需要假造机具备类卸载的功能，以保证永世代不会溢出。
内存模型实例

1. public class  PersonDemo
2. {
3.     public static void main(String[] args)
4.     {   //局部变量p和形参args都在main方法的栈帧中
5.         //new Person()对象在堆中分配空间
6.         Person p = new Person("zs",18);
7.         p.a = "cn1"；//重新赋值a在堆中,"cn1"被放入串池中
8.         //sum在栈中，new int[10]在堆中分配空间
9.         int[] sum = new int[10];
10.     }
11. }
12. class Person //模板在方法区
13. {   
14.     //实例变量在堆中。“cn”常量在常量池中
15.     private String a = "cn";
16.     //实例变量name和age在堆(Heap)中分配空间
17.     private String name;
18.     private int age;
19.     //类变量(引用类型)name1在方法区(Method Area)和"cn"在常量池中
20.     private static String name1 = "cn";
21.     //类变量(引用类型)name2在方法区(Method Area)
22.     //"cn"已存在，在常量池中，name2指向常量池中的"cn"
23.     private static String name2 = new String("cn");
24.     //num在堆中，new int[10]也在堆中
25.     private int[] num = new int[10];
26.    
27.    
28.     Person(String name,int age)
29.     {   
30.         //this及形参name、age在构造方法被调用时
31.         //会在构造方法的栈帧中开辟空间
32.         this.name = name;
33.         this.age = age;
34.     }
35.    
36.    //setName()方法属于类模板，加载在方法区中。但是调用时会压入栈中，并将局部变量name放入，而后name进行值传递传进name的地址
37.     public void setName(String name)
38.     {
39.         this.name = name;
40.     }
41.     //speak()方法在方法区中
42.     public void speak()
43.     {
44.         System.out.println(this.name+"..."+this.age);
45.     }
46.     //showCountry()方法在方法区中
47.     public static void  showCountry()
48.     {
49.         System.out.println("country");
50.     }
51. }

复制代码

其内存模型如下：

这里固然描述的常量池在方法区中，只作为明白。也可以明白为在堆中，或者元空间
面试题专栏

Java面试题专栏已上线，欢迎访问。

• 如果你不知道简历怎么写，简历项目不知道怎么包装；
  
• 如果简历中有些内容你不知道该不该写上去；
  
• 如果有些综合性问题你不知道怎么答；
  

那么可以私信我，我会尽我所能帮助你。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。