JVM——初体验

程序员小李_

已于 2023-06-01 19:05:59 修改

阅读量550

点赞数

分类专栏：笔记 JVM Java 文章标签： jvm java 面试

于 2023-05-15 18:01:17 首次发布

本文链接：https://blog.csdn.net/qq_51936245/article/details/130689856

版权

笔记同时被 3 个专栏收录

24 篇文章 0 订阅

订阅专栏

Java

19 篇文章 0 订阅

订阅专栏

JVM

1 篇文章 0 订阅

订阅专栏

JVM初体验

面试常见：

请谈谈你对JVM的理解？

JVM（Java Virtual Machine），俗称Java虚拟机。它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。

更全面地说，我认为能够全面了解JVM需要以下几个方面的知识：

JVM基本架构：JVM包括了类加载器、执行引擎、运行数据区和本地方法接口等几个重要组成部分。理解这些组成部分的作用和相互关系，对于深入了解JVM非常重要。
Java字节码、Class文件格式和反编译：了解Java字节码和Class文件的格式，可以帮助我们对于Java程序的编译、运行和调试有更深入的了解，并且可以进行反编译来查看程序的具体实现。
内存模型和垃圾回收机制：Java程序中的内存管理是由JVM负责的，它包括了堆区、栈区、方法区等，同时还有垃圾回收机制来自动回收不再使用的内存。理解内存模型和垃圾回收机制可以避免内存泄漏和内存溢出等问题。
JIT编译器：JVM中的JIT编译器可以将热点代码编译成本地机器代码，以便提升程序的执行效率。理解JIT编译器的原理可以帮助我们编写更高效的Java程序。
调优和诊断工具：JVM提供了丰富的调优和诊断工具，比如JConsole、VisualVM、JMC等。掌握这些工具的使用可以帮助我们快速诊断和定位程序问题，并进行JVM参数的调优。
JVM的性能监控和调优：JVM的性能监控和调优是Java程序优化的一个重要方面，可以通过JVM参数调优、GC日志分析、并发性分析来找出程序瓶颈并优化程序性能。

综上所述，JVM是Java程序运行的核心环境，理解JVM的工作原理和机制可以帮助我们编写出更高效、可靠、安全的Java程序，并进行性能调优和问题排查。

什么是OOM，什么是栈溢出StackOverFlowError? 怎么分析?
JVM的常用调优参数有哪些?
内存快照如何抓取，怎么分析Dump文件？
谈谈JVM中，类加载器你的认识

1.JVM的位置

图 JVM图解

2.JVM的体系结构

图 .java->.class的变化

百分之99的JVM调优都是在堆中调优，Java栈、本地方法栈、程序计数器是不会有垃圾存在的。

解释器：把源代码翻译成相对更加高效率的中间码，然后立即执行它。

3. 类加载器
作用：加载Class文件~

类加载器的作用

编译器：把.java文件编译为.class字节码文件，并做格式检查

字节码校验器:

1.字节码验证：

检查class文件的把呢不能和jvm版本是否兼容

检查代码是否会破坏系统完整性

检查代码是否有栈溢出的情况

检查当前代码参数类型是否正确

类在经过Class Loader之后的变化
1.虚拟机自带的加载器
2.启动类(根)加载器
3.扩展类加载器
4.应用程序加载器
5.百度:双亲委派机制

4. 双亲委派机制
//双亲委派机制:安全
// 1. APP–>EXC—B0OT(最终执行)
// B0OT
// EXC
// APP
1.类加载器收到类加载的请求
2.将这个请求向上委托给父类加载器去完成，一直向上委托，直到启动类加载器
3.启动加载器检查是否能够加载当前这个类，能加载就结束，使用当前的加载器，否则，抛出异常，通知子加载器进行加载
4.重复步骤3
Class Not Found异常就是这么来的
Java早期的名字：C+±-
Java = C++:去掉繁琐的东西，指针，内存管理~

类加载器

JVM自带的加载器(3种)
- 启动类加载器:Bootstrap ClassLoader,又名根类加载器或引导类加载器
- 拓展类加载器:Extension ClassLoader
- 系统类加载器:Application ClassLoader,又名应用类加载器
用户自定义的类加载器,一般是java.lang.ClassLoader

Java早期Java Applet需要从远程下载Java类文件到浏览器中并执行.

在java.net包中，JDK提供了一个更加易于使用的类加载器URLClassLoader，来扩展ClassLoader，能够从本地或网络上指定的位置加载类。我们可以使用该类作为自定义的类加载器使用

热部署类加载器
- 相同的类被同一个类加载器多次加载，则会报错。因此热部署是让同一个类文件被不同的类加载器加载重复加载即可。
- 我们不能调用loadClass方法，而应该调用findClass方法，避免双亲委派机制，从而实现同一个类被加载多次，实现热部署

类加载器的种类：

1-启动类加载器，负责加载%JAVA_HOME%\bin目录下的所有jar包，或者是-Xbootclasspath参数指定的路径jdk中的rt.jar；

2-扩展类加载器：负责加载%JAVA_HOME%\bin\ext目录下的所有jar包，或者是java.ext.dirs参数指定的路径；

3-应用程序类加载器：负责加载用户类路径上所指定的类库，如果应用程序中没有自定义加载器，那么次加载器就为默认加载器。

双亲委派机制

委派机制图:

双亲委派机制的工作过程:

类加载器收到类加载的请求;
把这个请求委托给父加载器去完成,一直向上委托,直到启动类加载器;
启动类加载器检查能不能加载(使用findClass()方法),能加载就结束;否则抛出异常,通知子加载器进行加载;
重复步骤三.

接下来举个例子：

大家所熟知的Object类，直接告诉大家，Object默认情况下是启动类加载器进行加载的。假设我也自定义一个Object，并且制定加载器为自定义加载器。现在你会发现自定义的Object可以正常编译，但是永远无法被加载运行。

这是因为申请自定义Object加载时，总是启动类加载器，而不是自定义加载器，也不会是其他的加载器。

5. 沙箱安全机制

Java安全模型的核心就是Java沙箱(sandbox) ,
什么是沙箱?沙箱是一个限制程序运行的环境。沙箱机制就是将Java代码限定在虚拟机(JVM)特定的运行范围中，并且严格限制代码对本地系统资源访问，通过这样的措施来保证对代码的有效隔离，防止对本地系统造成破坏。
沙箱主要限制系统资源访问，那系统资源包括什么? CPU、内存、文件系统、网络。不同级别的沙箱对这些资源访问的限制也可以不一样。
所有的Java程序运行都可以指定沙箱，可以定制安全策略。
在Java中将执行程序分成本地代码和远程代码两种，本地代码默认视为可信任的，而远程代码则被看作是不受信的。对于授信的本地代码,可以访问一切本地资源。而对于非授信的远程代码在早期的Java实现中，安全依赖于沙箱Sandbox)机制。如下图所示JDK1.0安全模型。

图 JDK1.0安全模型
但如此严格的安全机制也给程序的功能扩展带来障碍，比如当用户希望远程代码访问本地系统的文件时候，就无法实现。因此在后续的Java1.1版本中，针对安全机制做了改进，增加了安全策略，允许用户指定代码对本地资源的访问权限。如下图所示JDK1.1安全模型

图 JDK1.1安全模型
在Java1.2版本中，再次改进了安全机制，增加了代码签名。不论本地代码或是远程代码，都会按照用户的安全策略设定，由类加载器加载到虚拟机中权限不同的运行空间，来实现差异化的代码执行权限控制。如下图所示

图 JDK1.2安全模型
当前最新的安全机制实现，则引入了域(Domain)的概念。虚拟机会把所有代码加载到不同的系统域和应用域,系统域部分专门负责与关键资源进行交互，而各个应用域部分则通过系统域的部分代理来对各种需要的资源进行访问。虚拟机中不同的受保护域(Protected Domain),对应不一样的权限(Permission)。存在于不同域中的类文件就具有了当前域的全部权限，如下图所示最新的安全模型(jdk 1.6)

图 JDK1.6安全模型

组成沙箱的基本组件

●字节码校验器(bytecode verifier) :确保Java类文件遵循Java语言规范。这样可以帮助Java程序实现内存保护。但并不是所有的类文件都会经过字节码校验，比如核心类。
●类裝载器(class loader) :其中类装载器在3个方面对Java沙箱起作用

它防止恶意代码去干涉善意的代码;
它守护了被信任的类库边界;
它将代码归入保护域,确定了代码可以进行哪些操作。

虚拟机为不同的类加载器载入的类提供不同的命名空间，命名空间由一系列唯一的名称组成，每一个被装载的类将有一个名字，这个命名空间是由Java虚拟机为每一个类装载器维护的，它们互相之间甚至不可见。
类装载器采用的机制是双亲委派模式。
1.从最内层JVM自带类加载器开始加载,外层恶意同名类得不到加载从而无法使用;
2.由于严格通过包来区分了访问域,外层恶意的类通过内置代码也无法获得权限访问到内层类，破坏代码就自然无法生效。

存取控制器(access controller) :存取控制器可以控制核心API对操作系统的存取权限，而这个控制的策略设定,可以由用户指定。
安全管理器(security manager) : 是核心API和操作系统之间的主要接口。实现权限控制，比存取控制器优先级高。
安全软件包(security package) : java.security下的类和扩展包下的类，允许用户为自己的应用增加新的安全特性，包括:

 安全提供者
 消息摘要
 数字签名
 加密
　 鉴别

6.Native

native :凡是带了native关键字的，说明java的作用范围达不到了，回去调用底层c语言的库!
会进入本地方法栈
调用本地方法本地接口 JNI (Java Native Interface)
JNI作用:开拓Java的使用，融合不同的编程语言为Java所用!最初: C、C++
Java诞生的时候C、C++横行，想要立足，必须要有调用C、C++的程序
它在内存区域中专门开辟了一块标记区域: Native Method Stack，登记native方法
在最终执行的时候，加载本地方法库中的方法通过JNI
例如：Java程序驱动打印机，管理系统，掌握即可，在企业级应用比较少
private native void start0();
//调用其他接口:Socket. . WebService~. .http~

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等等，不多做介绍!

7.PC寄存器
程序计数器: Program Counter Register
每个线程都有一个程序计数器，是线程私有的，就是一个指针, 指向方法区中的方法字节码(用来存储指向像一条指令的地址，也即将要执行的指令代码)，在执行引擎读取下一条指令, 是一个非常小的内存空间，几乎可以忽略不计

8.方法区 Method Area
方法区是被所有线程共享,所有字段和方法字节码，以及一些特殊方法，如构造函数,接口代码也在此定义,简单说，所有定义的方法的信息都保存在该区域,此区域属于共享区间;
静态变量、常量、类信息(构造方法、接口定义)、运行时的常量池存在方法区中，但是实例变量存在堆内存中，和方法区无关

图类实例化后
9.栈

图为什么main()先执行，最后结束~
栈:先进后出
桶:后进先出
队列:先进先出( FIFO : First Input First Output )
栈:栈内存,主管程序的运行,生命周期和线程同步;
线程结束，栈内存也就是释放,对于栈来说,不存在垃圾回收问题
一旦线程结束，栈就Over!
栈内存中:

9大基本类型+对象引用+实例的方法

栈运行原理:栈帧
栈满了: StackOverflowError

图栈的位置示意图

图栈帧图解栈底部子帧指向上一个栈的方法上一个栈的父帧指向栈底部方法
10.三种JVM
●Sun公司HotSpot Java Hotspot™ 64-Bit Server VM (build 25.181-b13,mixed mode)
●BEA JRockit
●IBM J9VM
我们学习都是: Hotspot

11.堆
Heap, 一个JVM只有一个堆内存，堆内存的大小是可以调节的。
类加载器读取了类文件后，一般会把什么东西放到堆中?
类, 方法，常量,变量~，保存我们所有引用类型的真实对象;
堆内存中还要细分为三个区域:
●新生区(伊甸园区) Young/New
●养老区old
●永久区Perm

图堆内存详细划分
GC垃圾回收,主要是在伊甸园区和养老区~
假设内存满了,OOM,堆内存不够! java.lang.OutOfMemoryError:Java heap space
永久存储区里存放的都是Java自带的例如lang包中的类如果不存在这些，Java就跑不起来了
在JDK8以后，永久存储区改了个名字(元空间)

12.新生区、老年区
新生区
●类:诞生和成长的地方，甚至死亡;
●伊甸园，所有的对象都是在伊甸园区new出来的!
●幸存者区(0,1)

图重GC和轻GC
伊甸园满了就触发轻GC，经过轻GC存活下来的就到了幸存者区，幸存者区满之后意味着新生区也满了，则触发重GC，经过重GC之后存活下来的就到了养老区。
真理:经过研究，99%的对象都是临时对象!|

13.永久区
这个区域常驻内存的。用来存放JDK自身携带的Class对象。Interface元数据，存储的是Java运行时的一些环境~ 这个区域不存在垃圾回收，关闭虚拟机就会释放内存
●jdk1.6之前:永久代,常量池是在方法区;
●jdk1.7:永久代,但是慢慢的退化了，去永久代，常量池在堆中
●jdk1.8之后:无永久代,常量池在堆里面

图 JVM探究
元空间：逻辑上存在，物理上不存在 (因为存储在本地磁盘内) 所以最后并不算在JVM虚拟机内存中

注意字符串常量池是在堆里面的，而不是元空间，我们所说的常量池是运行时常量池放在元空间里面，字符串常量池和类常量池是在编译期间诞生的

运行时常量池和字符串常量池的关系

常量池具体包含的内容有

方法区先是位于永久区和元空间，并不位于堆上，只是逻辑上在堆里面，但是被称为非堆。

元空间是方法区的一种实现，方法区是虚拟机规范规定的。

轻gc和重gc分别在什么时候发生_什么是

Minor GC/Major GC

什么是 Minor GC/Major GC

首先我们先科普一下JVM 经典的堆布局:

对于经典的 JVM heap 布局，有两个区域比较清晰，首先是Young 区,一般会来存放年轻的对象或者刚被创建没多久的对象。其次是 Old 区，也就是老年代，一般会来存放比较长寿的对象，或者从 young 区晋升的对象。

对于young 区我们又有三个区域，一个是 Eden 区，还有两个大小相等的 Survivor 区。

新生的对象会在 Eden 区创建。

Minor GC
此时如果新生的对象无法在 Eden 区创建（Eden 区无法容纳) 就会触发一次Young GC 此时会将 S0 区与Eden 区的对象一起进行可达性分析，找出活跃的对象，将它复制到 S1 区并且将S0区域和 Eden 区的对象给清空，这样那些不可达的对象进行清除，并且将S0 区和 S1区交换。

但是这里会产生一个问题，Q:为啥会有两个 Survivor 区？

A: 因为假设设想一下只有一个 Survibor 区那么就无法实现对于 S0 区的垃圾收集，以及分代年龄的提升。

Major GC
发生在老年代的GC ，基本上发生了一次Major GC 就会发生一次 Minor GC。并且Major GC 的速度往往会比 Minor GC 慢 10 倍。

什么时候发生Major GC
既然我们已经知道了 Minor GC 是在 Eden 区快满的情况下才会触发

Q:那么 Major GC 呢?
A:

对于一个大对象，我们会首先在Eden 尝试创建，如果创建不了，就会触发Minor GC
随后继续尝试在Eden区存放，发现仍然放不下
尝试直接进入老年代，老年代也放不下
触发 Major GC 清理老年代的空间
放的下成功
放不下 OOM

详见下图:

补充一下对象晋升的条件：当对象经过一次Minor GC后仍存活，并且它已经在Survivor区中存活了一定次数（一般是15），那么这个对象就会被晋升到老年代中，这样可以避免Survivor区被填满。而一次Full GC也会晋升所有存活的对象至老年代。

此外，稍微补充一下堆参数方面的知识，比如：

-Xmx和-Xms控制堆的最大和最小大小，
-XX:NewRatio控制老年代和新生代的大小比值等等。

避免频繁的Full GC
避免定义过大的对象(数组)
避免将过大对象定义为静态变量

14.堆内存调优
测试代码

public static void main(String[] args) {
String s = "";
while (true) {
s += "11111111111111111111111111111111111111111111111111111";
}
}

图虚拟机放入参数

图控制台报错到最后会报OOM（OutOfMemory）堆内存溢出报错

在一个项目中，突然出现了OOM故障,那么该如何排除研究为什么出错~
能够看到代码第几行出错:内存快照分析工具，MAT, Jprofiler

Dubug, 一行行分析代码!
MAT, Jprofiler作用
分析Dump内存文件,快速定位内存泄露;
获得堆中的数据
获得大的对象~

MAT是eclipse集成使用在这里不学

Jprofile使用
1.在idea中下载jprofile插件
2.联网下载jprofile客户端
3.在idea中VM参数中写参数 -Xms1m -Xmx8m -XX: +HeapDumpOnOutOfMemoryError
4.运行程序后在jprofile客户端中打开找到错误告诉哪个位置报错
命令参数详解
// -Xms设置初始化内存分配大小/164
// -Xmx设置最大分配内存，默以1/4
// -XX: +PrintGCDetails // 打印GC垃圾回收信息
// -XX: +HeapDumpOnOutOfMemoryError //oom DUMP

MAT,Jprofiler作用

分析Dump内存文件,快速定位内存泄漏

获得堆中的数据,获得大的对象.

MAt是集成在Eclipse中使用.

IDEA+Jprofile https://blog.csdn.net/wytocsdn/article/details/79258247
Jprofile https://blog.csdn.net/a294039255/article/details/84863892

堆内存分配的原则

Native

介绍

初次遇见 native是在 java.lang.Object 源码中的一个hashCode方法：

1	public native int hashCode();

为什么有个native呢？这是我所要学习的地方。所以下面想要总结下native。

一、认识 native 即 JNI,Java Native Interface

凡是一种语言，都希望是纯。比如解决某一个方案都喜欢就单单这个语言来写即可。Java平台有个用户和本地C代码进行互操作的API，称为Java Native Interface (Java本地接口)。

二、用 Java 调用 C 的“Hello，JNI”

我们需要按照下班方便的步骤进行：

1、创建一个Java类，里面包含着一个 native 的方法和加载库的方法 loadLibrary。HelloNative.java 代码如下：


public class HelloNative
 
{
 
  static
 
  {
 
    System.loadLibrary("HelloNative");
 
  }
 
    
  public static native void sayHello();
   
 
  @SuppressWarnings("static-access")
 
  public static void main(String[] args)
 
  {
 
    new HelloNative().sayHello();
 
  }
 
}

首先让大家注意的是native方法，那个加载库的到后面也起作用。native 关键字告诉编译器（其实是JVM）调用的是该方法在外部定义，这里指的是C。如果大家直接运行这个代码， JVM会告之：“A Java Exception has occurred.”控制台输出如下：

12345	Exception in thread ``"main" java.lang.UnsatisfiedLinkError: no HelloNative in java.library.path`` ``at java.lang.ClassLoader.loadLibrary(Unknown Source)`` ``at java.lang.Runtime.loadLibrary0(Unknown Source)`` ``at java.lang.System.loadLibrary(Unknown Source)`` ``at HelloNative.<clinit>(HelloNative.java:``5``)

这是程序使用它的时候，虚拟机说不知道如何找到sayHello。

总结

native:凡是带了native关键字的，说明java的作用范围达不到了，回去调用底层c语言的库!
会进入本地方法栈，调用本地方法本地接口 JNI
JNI的作用：扩展Java的使用，融合不同的编程语言为Java所用!最初：C,C++
Java诞生的时候，c、c++横行，想要立足就必须要有调用c、c++的程序
它在内存区域中专门开辟了一块标记区域，Native Method Stack 登记native方法
在最终执行的时候，加载本地方法库中的方法通过JNI
Java程序驱动打印机、管理系统……

native关键字:凡是带有native关键字的，说明java的作用范围达不到了，回去调用底层c语言的库！

PC寄存器

程序计数器：Program Counter Register

每个线程都有一个程序计数器，是线程私有的，就是一个指针，指向方法区中的方法字节码(用来存储指向一条指令的地址，也即将要执行的指令代码)

在执行引擎读取下一条指令，是一个非常小的内存空间，几乎可以忽略不计。

它也是保证了程序执行的有序性的关键

程序计数器(Program Counter Register)是Java虚拟机中的一种重要的内存区域，它是线程私有的，每个线程都有一个程序计数器，用于存储下一条要执行的指令的地址。在Java程序执行过程中，程序计数器的值会随着执行的指令不断发生变化。

由于程序计数器的内存占用非常小，一般只占用几十字节的内存空间，因此它是虚拟机内部内存管理的一部分，不像堆内存和栈内存那样需要手动释放内存。

程序计数器也是保证Java程序执行的有序性的关键。在Java程序运行的过程中，线程会根据程序计数器中存储的地址来选择并执行对应的指令，从而使得Java程序按照预期执行。

需要注意的是，程序计数器存储的是下一条要执行的指令的地址，而对于Java方法来说，方法体中的指令是按顺序编排的。因此，如果程序计数器的值发生错误，可能会导致Java程序执行出现异常，并且也可能会影响虚拟机的安全性和稳定性。

总而言之，程序计数器是Java虚拟机中的一种重要的内存区域，通过存储下一条指令的地址来保证Java程序的执行有序性。

方法区

Method Area 方法区

Java Method Area(方法区)是一种被所有线程共享的内存区域，用于存储类信息、常量、静态变量、类名、方法名和方法字节码等信息。在运行Java程序时，所有类的定义和已经被加载的类信息都存储在该区域中。

不同于Java堆和程序计数器这样的线程私有的区域，Java Method Area属于Java虚拟机的共享区间。

Java Method Area保存的是Java类的元数据信息，比如说类的字段、方法信息等。同时也保存类的常量池信息，存放在代码中出现的字面量和符号引用。除此之外，Java Method Area也会保存Java虚拟机运行时生成的类信息，如动态代理类信息等。

Java Method Area是Java虚拟机核心内存区域之一，由于其中包含了Java程序运行过程中的基本元数据信息，因此在程序执行的过程中不断地动态变化，而与之相关的JVM中的垃圾回收也必须对Method Area进行回收，以便保证Java程序内存的管理和使用的效率和稳定性。

静态变量、常量、类信息(构造方法、接口定义)、运行时的常量池存在方法区中，但是实例变量存在堆内存中，和方法区无关

static final class 常量池

static：表示该类的静态成员（包括静态属性、静态方法等）在程序运行时只会被加载一次，不需要每次创建对象都重新加载一遍。这样可以提高程序的运行效率。
final：表示该类是不可变的，也就是说，它的属性和方法都不会被修改。final类通常用于创建不可变对象，这样可以保证代码的健壮性和可维护性。
class：表示该关键字后面的代码是一个类的定义。

至于常量池(Constant Pool)，它指的是一段特殊的内存空间，用于保存Java程序中使用到的常量、符号引用（如类和方法名）、字面量、代码中的各种符号信息等，以供程序在运行时使用。常量池是所有线程共享的，并且位于Java类文件内部。

在Java程序中，常量池被广泛用于存储各种常量信息，如数字常量、字符串常量等。在程序执行时，Java虚拟机会根据符号引用来查找对应的常量池中的信息，并使用它们执行相应的指令。在Java 8之后，常量池还被扩展用于支持Lambda表达式和方法句柄等新特性。

总之，"static final class"表示一个不可变的静态类，而常量池则是Java程序中用于保存常量、符号引用等信息的一种特殊内存区域。

栈

是一种数据结构

喝多了吐就是栈，吃多了拉就是队列

为什么main()执行，最后结束~

栈：栈内存，主管程序的运行，生命周期和线程同步，线程结束，栈内存也就是释放

线程接口，栈内存也就是释放，对于栈来说，不存在垃圾回收问题，一旦线程结束，栈就Over！

栈存储: 8大基本类型 + 对象引用 +实例方法

栈（Stack）是Java虚拟机内存管理的一部分，用于存储程序执行的上下文信息。它是线程私有的，每个线程都有一个自己的栈用于存储调用栈和局部变量等信息。

栈是一种LIFO（Last In First Out）的数据结构，新的元素被添加进来时会被放在栈顶，而元素被移除时则是从栈顶开始。在Java程序中，栈主要被用于保存方法调用的信息，每当一个方法被调用时，Java虚拟机都会为其创建一个新的栈帧（Stack Frame）用于存储该方法的参数、返回值、局部变量、操作数栈以及方法返回地址等信息。

在栈中，每个栈帧都包含了一些重要的信息，比如该方法的参数、返回值、局部变量等，以及保存上一个方法返回地址的信息。当当前方法执行结束时，Java虚拟机会弹出当前栈帧，并返回到上一个方法的返回地址继续执行。

需要注意的是，Java虚拟机对栈的大小设置有限制，在不同的JVM实现中栈的大小不同，当栈大小超出限制时，会抛出java.lang.StackOverflowError异常。因此，在设计程序时需要合理地控制递归深度等调用栈的使用情况，以免导致程序出错。

总而言之，栈是Java虚拟机内存管理的一部分，用于存储程序执行的上下文信息，存储方法调用栈和局部变量。它是线程私有的，每个线程都有一个自己的栈。

在Java虚拟机内存管理中，栈、方法区、堆和常量池是四种不同的内存区域，它们之间有如下几种关系：

栈和方法区：每个线程都有一个自己的栈用于存储调用栈和局部变量等信息，而方法区是所有线程共享的内存区域，用于存储类信息、常量池等数据。当一个线程调用一个方法时，Java虚拟机会为该方法创建一个新的栈帧压入栈顶，其中包含了该方法的参数、返回值、局部变量等信息，并在方法区中存储该方法的字节码和常量池等信息。
栈和堆：栈和堆是Java程序中两个最重要的内存区域。栈用于保存方法调用栈和局部变量等信息，是一个LIFO（Last In First Out）的数据结构，而堆则用于存储对象的实例和数组等数据，是一个动态分配的内存区域。当一个对象需要实例化时，Java虚拟机会在堆中为其分配一段连续的内存空间，并将其首地址保存在该对象的引用变量中。
常量池和堆：常量池是Java程序中用于保存常量、符号引用等信息的一种特殊内存区域，位于类加载器加载的类的元数据中。在Java程序中，常量池被广泛用于存储各种常量信息，如数字常量、字符串常量等。而堆则用于存储对象的实例和数组等数据，在常量池中定义的字符串常量等数据可以被多个对象共享，在堆中仅需存储一份副本即可。

总之，栈、方法区、堆和常量池是Java虚拟机内存管理中的四个重要区域，分别用于存储方法调用栈和局部变量、类信息和常量池、对象实例和数组等数据、以及常量和符号引用等元数据。它们之间有密切的联系和交互，共同构成了Java程序的内存模型。

堆

GC垃圾回收，主要是在伊甸园区和养老区~

新生区

老年区

是上面新生区剩下的。经过新生的垃圾回收还可以保留下来，就可以进入老年区。

永久区/元空间

堆内存分布

堆

JDK1.8以后的堆内存空间

元空间在逻辑上是在堆中存在的，但是实际上，物理内存就是新生代+老年代

所以：元空间又被称为非堆 ===> 元空间逻辑上存在于堆中，但实际的物理内存中并不存在

内存分配

堆内存大小的分配

但是可以自己调配内存大小

模拟OOM

将最大内存和最大运行内存调整到很小，一下子堆内存就会满了

	调优参数解析
最大内存8m:	-Xms8m
最大运行内存8m	-Xmx8m
打印GC信息	-XX: +PrintGCDetails

解决OOM

处理OOM堆内存满了的问题

原因：堆内存满了，会爆出OOM异常

处理方式步骤：
1.按照上述，先调整堆内存空间大小，放大一些

上述1步骤：没有解决—>有垃圾代码或者死循环代码无限占用内存空间

2.分析内存看一下哪里会出现问题。

相关客户端以及插件的安装与使用指导网址：

https://www.kuangstudy.com/bbs/1369899213336367105

然后安装客户端

安装及使用博文连接：

https://blog.csdn.net/qq_43012792/article/details/107437471?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163047952216780274146327%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=163047952216780274146327&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduend~default-1-107437471.first_rank_v2_pc_rank_v29&utm_term=jprofiler11%E9%9B%86%E6%88%90idea&spm=1018.2226.3001.4187

JProfiler

制造异常

package com.Hao.ClassLoader;


import java.util.ArrayList;

public class StreamTest {
    byte[] array = new byte[1*1024*1024];//1m
    public static void main(String[] args) {
        ArrayList<StreamTest> list = new ArrayList<>();
        int count = 0;

        try {
            while (true) {
                list.add(new StreamTest());
                count += 1;
            }
        } catch (Exception e) {
            System.out.println("count:" + count);
            e.printStackTrace();
        }
    }
}

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	at com.Hao.ClassLoader.StreamTest.<init>(StreamTest.java:7)
	at com.Hao.ClassLoader.StreamTest.main(StreamTest.java:14)

输入：

//大意：最大内存1m，运行内存8m，只要出现OutOfMemoryError的错误就在堆中Dump出来
-Xms1m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError

此时再次运行就会dump出来文件

java.lang.OutOfMemoryError: Java heap space
Dumping heap to java_pid6832.hprof ...
Heap dump file created [6862472 bytes in 0.024 secs]
    //在下面打开当前class文件夹中

然后往上找

在src目录中找到并双击打开

点击Biggest Objects找问题：

错误信息定位：

步骤：先看一下哪个对象特别大，再看一下它运行的线程，点击查看定位信息行数

上述dump的命令后面的错误可以修改一下，有什么错就换成什么错误在后面即可

-XX:+HeapDumpOn[错误类型]

栈里面不存在垃圾，一般调优什么的都是在堆中。

GC

GC	Garbage Collection 垃圾收集
Java中	GC的对象是Java堆和方法区(即永久区)

Eden与Survivor的内存大小比例为8:1:1

GC面试题：

JVM的内存模型和分区 ~ 详细到每个区放什么？
堆里面的分区有哪些？Eden,form(幸存一区) , to(幸存二区，谁空谁是to), 老年区，说说它们的特点！
GC的算法有哪些？标记清除法、复制算法、标记压缩法，引用计数器，它们是怎么用的？
轻GC和重GC分别在什么时候发生

答：

JVM的内存模型和分区

Java虚拟机的内存模型包括了两个主要组成部分：堆内存和栈内存。堆内存主要用于存储Java对象实例。而栈内存用来存放局部变量和操作数栈。

堆内存又分为新生代和老年代，新生代又分为Eden空间、幸存一区和幸存二区，它们用于存储新分配的对象。其中，新生成的对象都会被分配到Eden空间中。当Eden空间中的对象被GC后，存活的对象会被复制到幸存一区或幸存二区。在垃圾回收时，幸存一区和幸存二区的对象会根据其存活时间进行复制到另外一区。经过多次垃圾回收后，仍然存活的对象会被晋升到老年代中。老年代用于存储较长时间存活的对象。

堆里面的分区有哪些？Eden,form(幸存一区) , to(幸存二区，谁空谁是to), 老年区，说说它们的特点！

Eden空间：用于存储新生成的对象，空间较大。
幸存一区和幸存二区：用于存储已经经过一次垃圾回收的对象。在垃圾回收时，幸存一区和幸存二区的对象会根据其存活时间进行复制到另外一区。因此，幸存一区和幸存二区是相互交替使用的。
老年区：用于存储较长时间存活的对象。因为老年代垃圾回收的频率很低，所以老年代的内存空间被设计得相对较大。

GC的算法有哪些？标记清除法、复制算法、标记压缩法，引用计数器，它们是怎么用的？

标记清除法：在标记阶段会标记所有可以被回收的对象，标记完成后进行清理。标记清除法的主要缺点是无法避免内存碎片的产生，这会导致频繁进行垃圾回收，效率比较低。
复制算法：将内存空间分为两个相等的区域，每次只使用其中一个，当这个区域使用率达到一定阈值时，就将其中的存活对象复制到另一个区域上，之后再清理旧的区域。这种算法的优点是简单高效，缺点是会浪费一半的内存空间。
标记压缩法：在标记阶段和清理阶段后，所有存活对象会被整理到内存空间的一端，空闲的内存空间会被移动到另一端。标记压缩法可以避免内存碎片的产生，能够提高垃圾回收的效率。
引用计数器：记录每个对象被引用的次数，当对象的引用计数为0时，就表示该对象可以被回收。引用计数器的主要缺点是无法处理循环引用的情况，需要额外的处理方式。

轻GC和重GC分别在什么时候发生？

轻GC一般在新生代进行，发生频率较高，用于清理新分配的对象。当Eden空间不够用时，会触发一次轻GC。轻GC使用的是复制算法，速度较快。经过多次轻GC后，仍然存活的对象会被晋升到老年代中。

重GC一般在老年代进行，发生频率较低，也被称为Full GC，用于清理老年代内存和整理内存空间。一般情况下，重GC会在以下情况发生：

VM堆的使用达到了一定的阈值；
在进行轻GC时，发现存活的对象太多，无法继续存放在幸存区中；
用户手动调用System.gc()方法进行垃圾回收。

重GC由于要处理的内存较多，因此速度比轻GC慢。

引用计数法

引用计数算法算是实现最简单的了，它只需要一个简单的递归即可实现。现代编程语言比如Lisp，Python，Ruby等的垃圾收集算法采用的就是引用计数算法。现在就让我们来看下引用计数算法(reference counting)是如何工作的。

原理:实际上是通过在对象头中分配一个空间来保存该对象被引用的次数。如果该对象被其它对象引用，则它的引用计数+1，如果删除对该对象的引用，那么它的引用计数就-1，当该对象的引用计数为0时，那么该对象就会被回收。

GC的时候会将计数器为0的对象C给销毁.

引用计数法无法解决循环引用的问题

缺点：一般对象的数量非常庞大，每个对象都需要给它附带一个计数器，消耗比较大，并不高效，所以用的比较少。

根搜索

1,1根搜索算法的概念：

由于引用计数算法的缺陷，所以JVM一般会采用一种新的算法，叫做根搜索算法。它的处理方式就是，设立若干种根对象，当任何一个根对象到某一个对象均不可达时，则认为这个对象是可以被回收的。

复制算法

2.复制算法(新生代)

复制算法的概念：

将原有的内存空间分为两块，每次只使用其中一块，在垃圾回收时，将正在使用的内存中的存活对象复制到未使用的内存块中，之后，清除正在使用的内存块中的所有对象，交换两个内存的角色，完成垃圾回收。

与标记-清除算法相比，复制算法是一种相对高效的回收方法
不适用于存活对象较多的场合，如老年代（复制算法适合做新生代的GC）
幸存区from和幸存区to中谁空谁是to,我们会将to中的数据复制到from中保持to中数据为空;
from和to区实际上为逻辑上的概念,保证to区一直空;
默认对象经过15次GC后还没有被销毁就会进入养老区.

流程:

将Eden区进行GC存活对象放入空的to区,将from区存活的放到空的to区
此时from区为空变成了to区,to区有数据变为from区
经过15次GCfrom区还存活的对象会被移动到养老区

好处:没有内存碎片

坏处:浪费了内存空间(to区为空)

复制算法最佳使用场景:对象存货度较低(如果存活度较高,则from区空间全部被占满导致会将全部内容复制到to区)

标记-清除

标记-清除算法

标记清除算法的概念：

标记-清除算法是现代垃圾回收算法的思想基础。标记-清除算法将垃圾回收分为两个阶段：标记阶段和清除阶段。一种可行的实现是，在标记阶段，首先通过根节点，标记所有从根节点开始的可达对象。因此，未被标记的对象就是未被引用的垃圾对象；然后，在清除阶段，清除所有未被标记的对象。

它的做法是当堆中的有效内存空间（available memory）被耗尽的时候，就会停止整个程序（也被成为stop the world），然后进行两项工作，第一项则是标记，第二项则是清除。

需要两次扫描,第一次扫描标记存活对象,第二次扫描清除没有被标记的对象

优点:不需要额外的空间

缺点:两次扫描严重浪费时间,并且还会产生内存碎片

标记-压缩

4.标记-压缩/整理算法(老年代)

概念：

标记-压缩算法适合用于存活对象较多的场合，如老年代。它在标记-清除算法的基础上做了一些优化。和标记-清除算法一样，标记-压缩算法也首先需要从根节点开始，对所有可达对象做一次标记；但之后，它并不简单的清理未标记的对象，而是**将所有的存活对象压缩到内存的一端；**之后，清理边界外所有的空间。

cc79889a-0856-4018-92c3-c51108c9caea

在标记清除算法上进行优化**,再扫描一次将存活对象移动到一起**

总结:
内存效率:复制算法>标记清除算法>标记压缩算法(时间复杂度)
内存整齐度:复制算法=标记压缩算法>标记清除算法
内存利用率:标记压缩算法=标记清除算法>复制算法
没有最好的算法,只有最合适的算法 GC:分代收集算法

年轻代:

存活率低
复制算法

老年代:
- 区域大:存活率
- 标记清除(内存碎片不是太多)+标记压缩混合实现

分代收集

5.分代收集算法（新生代的GC+老年代的GC）

当前商业虚拟机的GC都是采用的“分代收集算法”，这并不是什么新的思想，只是根据对象的存活周期的不同将内存划分为几块儿。一般是把Java堆分为新生代和老年代：短命对象归为新生代，长命对象归为老年代。

少量对象存活，适合复制算法：在新生代中，每次GC时都发现有大批对象死去，只有少量存活，那就选用复制算法，只需要付出少量存活对象的复制成本就可以完成GC。
大量对象存活，适合用标记-清理/标记-整理：在老年代中，因为对象存活率高、没有额外空间对他进行分配担保，就必须使用“标记-清理”/“标记-整理”算法进行GC。

注：老年代的对象中，有一小部分是因为在新生代回收时，老年代做担保，进来的对象；绝大部分对象是因为很多次GC都没有被回收掉而进入老年代。

//当执行GC时，会执行finalize方法，并且只会执行一次
system.gc();

Stop-The-World(part的清洁工,终止part来打扫)：

Java中一种全局暂停的现象。全局停顿，所有Java代码停止，native代码可以执行，但不能和JVM交互

多半情况下是由于GC引起。

少数情况下由其他情况下引起，如：Dump线程、死锁检查、堆Dump。

危害:长时间服务停止，没有响应（将用户正常工作的线程全部暂停掉）

https://www.cnblogs.com/qianguyihao/p/4744233.html

垃圾收集器

如果说收集算法是内存回收的方法论，垃圾收集器就是内存回收的具体实现。垃圾收集器是Java虚拟机内存管理的一部分，负责回收不再使用的对象，以便腾出内存空间。

在Java虚拟机中，垃圾收集器可以分为Serial、Parallel、CMS和G1四种类型。

Serial收集器是一种单线程的收集器，适用于单个CPU的环境，通常用于小型应用程序或开发和测试环境。
Parallel收集器是一种并行的收集器，可以利用多个CPU并行进行垃圾收集，它的垃圾收集方式是复制算法，适用于大型内存容量应用程序的垃圾回收。
CMS（Concurrent Mark-Sweep）收集器是一种并发的垃圾收集器，可以在应用程序运行的同时进行垃圾回收，适合对响应时间有要求的应用程序，并且不会造成停顿。
G1（Garbage First）收集器是一种JDK 7引入的新型垃圾收集器，它采用全局并发标记-整理算法来执行垃圾回收操作。G1是一种垃圾优先的收集器，它会优先回收回收价值最高的内存块。

垃圾收集器本质上是为了让Java开发者无需手动管理内存的释放，降低内存泄漏的风险，减轻开发工作量，并提高程序的性能和稳定性。

1.serial(串行)收集器

Serial收集器是JVM中最古老的收集器之一，也是最简单的一种收集器，完全基于串行的方式进行GC。

Serial收集器主要应用于Client端的Java应用，比如桌面应用、小型Web应用等等，这类应用对于响应时间和吞吐量要求不是很高，所以使用单线程的Serial收集器足够。

Serial收集器在进行垃圾收集的时候，会暂停整个应用的运行，将所有的对象都放到一个“年轻代”中，然后清除掉不再被使用的对象。由于是单线程的收集器，所以处理时效率比较低，但是对于小型应用来说，停顿的时间比较短，垃圾收集效果也比较明显。

在JDK9及之后的版本，Serial收集器逐渐被淘汰，主要是因为JVM优化的方向已经从单纯的响应时间转移到吞吐量方面，而Serial收集器在吞吐量方面的表现不够理想，被更高效的收集器所取代，比如Parallel和G1收集器。

2.并行收集器

并行收集器是一种基于多线程并行的方式进行GC的收集器，在进行垃圾回收时，会启动多个线程来同时处理垃圾回收工作，从而提高垃圾回收的效率，减少GC暂停时间。

在JDK 8及以前的版本中，JVM内置的主要并行收集器有ParNew、Parallel Scavenge和Parallel Old，其中ParNew是一种年轻代的并行收集器，Parallel Scavenge则是一种更注重吞吐量和CPU利用率的并行收集器，而Parallel Old则主要是针对老年代的并行收集器。

并行收集器主要适用于对吞吐量要求较高的应用，在处理大数据量和高并发的场景下具有优异的性能表现。同时，使用并行收集器还需要考虑系统硬件资源的限制，比如CPU核数和内存大小等因素，合理设置收集器参数可以根据系统配置来决定并行线程数量、年轻代和老年代的大小等属性。

2.1 PartNew

ParNew是一款基于并行多线程的垃圾回收器，主要用于年轻代的垃圾回收。与Serial收集器相比，ParNew收集器可以通过使用多个线程并行处理年轻代中的垃圾对象来提高垃圾收集效率。同时，ParNew收集器还可以与CMS收集器搭配使用，用于控制应用在进行CMS收集时的年轻代垃圾回收。

在运行时，ParNew收集器会将年轻代分成多个较小的区域，由多个线程并行扫描区域内的对象，标记需要回收的对象，然后进行垃圾回收。ParNew收集器使用复制算法进行垃圾回收，将回收后的对象复制到另外一块未被使用的内存空间中，如果空间不足则触发一次Minor GC。由于ParNew收集器具有并行处理、低停顿等优势，因此多应用在服务端的Java应用中，能够大大提高GC的效率。

需要注意的是，ParNew收集器不是CMS垃圾收集器的唯一年轻代GC组件，JDK8之后G1也使用了一种不同的带有年轻代并行收集组件的算法来实现收集。另外，JDK11开始，ParNew已经不再支持，取而代之的是Parallel Scavenge收集器。

2.2 Parallel收集器

Parallel收集器是一种年轻代并行回收收集器，它的目标是增强系统的吞吐量（throughput），即单位时间内程序运行的任务完成量。与ParNew相比，Parallel收集器对CPU资源的需求更高，同样是基于并行多线程机制来进行垃圾回收的，但是它会利用更多的CPU资源，同时减少GC停顿时间。

Parallel收集器使用复制算法进行垃圾回收，将整个年轻代分为多个区域进行并行处理，垃圾收集器和应用线程可以同时运行，不需要停顿应用线程，从而减少了应用线程的等待时间。

与ParNew和CMS相比，Parallel收集器的优势主要在于：

高吞吐量：Parallel收集器的垃圾处理速度较快，可以获得更高的吞吐量。
低延迟：Parallel收集器在进行垃圾回收时会使应用程序停顿，但是这个停顿时间要比CMS和G1收集器短。
容易调优：Parallel收集器相对于CMS和G1收集器，调优门槛较低，使用起来较为简单。

需要注意的是，Parallel收集器主要适用于多核CPU的系统，因为它会完全利用CPU资源进行并行处理，同时，Parallel收集器不适用于内存较大的系统，因为在处理大内存系统时会引发较高的GC停顿，从而降低系统的性能。

年轻代收集器：Parallel收集器只用于年轻代的垃圾回收，对于老年代的垃圾回收，需要使用另外的垃圾回收器。
多线程并行收集：Parallel收集器利用多个线程并行扫描年轻代中的对象，并发和并行的方式可以大幅提升年轻代垃圾回收的效率。
适用于高吞吐量应用：Parallel收集器旨在优化吞吐量，不适合对实时性要求较高，GC停顿时间敏感的应用程序。
不使用响应时间优先调度策略：Parallel收集器采用的是吞吐量优先策略，然而，这个策略不利于应用程序对请求响应时间的控制。

总之，Parallel收集器的优点在于优化吞吐量和没有过多的调优门槛，适应于对实时性要求不高且运行任务量较大的应用。但是如果应用程序对响应时间有严格需求，或者内存容量较大，可能就需要使用其他垃圾回收器来完成垃圾回收任务。

3.CMS收集器(并发标记清除)

Concurrent Mark Sweep 并发标记清除（应用程序线程和GC线程交替执行）
使用标记-清除算法
并发阶段会降低吞吐量（停顿时间减少，吞吐量降低）
老年代收集器（新生代使用ParNew）
-XX:+UseConcMarkSweepGC

CMS (Concurrent Mark Sweep)收集器是一个以获取最短回收停顿时间为目标的收集器。它是一种并发收集器，尽量避免应用程序停顿的目的是通过并发标记和并发清除两个过程来实现的。CMS收集器主要用于老年代的垃圾回收。

CMS收集器的工作过程如下：

初始标记（CMS initial mark）：暂停所有应用线程，标记出所有根对象，速度快。
并发标记（CMS concurrent mark）：启动应用线程，并发遍历整个老年代标记活跃对象。
并发预清理（CMS concurrent preclean）：在标记阶段，应用程序还在继续执行的过程中，垃圾容易生成，需要进行预清理，以避免浪费后面的垃圾收集时间。
最终标记（CMS remark）：暂停所有应用线程，重新标记，以确保标记的正确性。
并发清除（CMS concurrent sweep）：并发清除垃圾对象。
并发重置（CMS concurrent reset）：重置CMS收集器的内部状态。

与其他收集器相比，CMS收集器具有并发标记、低延迟、运行时垃圾回收等优点。不只是在执行垃圾回收的线程中，应用程序线程可以直接访问堆内存。但同时，CMS收集器在垃圾回收期间需要消耗更多的CPU和内存资源，可能导致一些性能上的损失，这就是一些用户所称的“CMS降速”。

需要注意的是，CMS收集器在执行过程中会产生大量的内存碎片，会导致老年代分配失败，触发Full GC，因此最好与ParNew收集器一同使用，只在需要进行Full GC的时候才会使用Serial收集器。另外，在并发标记和清除的过程中，应用程序仍然在运行，这就可能导致CMS收集器无法回收一些垃圾对象，增加了垃圾收集的负担。

4.G1收集器

https://blog.csdn.net/laomo_bible/article/details/83112622

G1 (Garbage First)收集器是一种面向服务端应用的垃圾收集器，采用了基于区域的内存管理模式，且有着优秀的垃圾回收性能和灵活的内存占用控制。

G1收集器在整个堆内存中设置了许多大小不一的区域（Region），每个区域可以是 1MB 到 32MB 不等。G1将整个堆内存分为了逻辑上连续的多个区域，每个区域的状态可能是Eden，Survivor，Old或Humongous等。

G1收集器的工作流程如下：

初始标记（Initial Marking）：标记出第一批垃圾对象，包括与GC Roots直接相关的对象、Survivor区中的对象以及老年代中的对象；
并发标记（Concurrent Marking）：与用户线程一起运行，同时标记出存活的对象，标记了少量对象之后，G1就会选出最需要被清理的Region来进行垃圾回收；
扫描删除（Mixed GC）：这一阶段主要是收集垃圾，回收垃圾的区域是由标记阶段的最耗费时间的Region优先决定的，G1会同时回收一部分可回收的Region；
再次标记（Remark）：由于标记过程是与用户线程并发执行的，标记阶段结束时可能又有新的垃圾产生，因此需要再次标记；
清理回收（Cleanup）：找到所有的垃圾对象进行删除；
空间压缩：如果有必要，G1收集器会对内存进行整理，以免产生内存碎片。

G1收集器相对于CMS收集器而言，它不仅具备CMS收集器的并发收集能力、低延迟，而且还具有更好的吞吐量、更高的垃圾回收效率和更优秀的内存管理效果。但是，由于区域化的内存管理模式，G1收集器也比其他一些收集器（如串行收集器或并行收集器）更加复杂。

总结来说， G1收集器采用了分代式的内存管理模式，同时利用了局部性原理和基于区域的内存管理技术，使得其可以兼顾吞吐量和回收延迟，从而全面提高应用系统的性能表现。

finalize()

14.finalize()方法详解

1. finalize的作用

finalize()是Object的protected方法，子类可以覆盖该方法以实现资源清理工作，GC在回收对象之前调用该方法。
finalize()与C++中的析构函数不是对应的。C++中的析构函数调用的时机是确定的（对象离开作用域或delete掉），但Java中的finalize的调用具有不确定性
不建议用finalize方法完成“非内存资源”的清理工作，但建议用于：① 清理本地对象(通过JNI创建的对象)；② 作为确保某些非内存资源(如Socket、文件等)释放的一个补充：在finalize方法中显式调用其他资源释放方法。其原因可见下文[finalize的问题]

2. finalize的问题

一些与finalize相关的方法，由于一些致命的缺陷，已经被废弃了，如System.runFinalizersOnExit()方法、Runtime.runFinalizersOnExit()方法
System.gc()与System.runFinalization()方法增加了finalize方法执行的机会，但不可盲目依赖它们
Java语言规范并不保证finalize方法会被及时地执行、而且根本不会保证它们会被执行
finalize方法可能会带来性能问题。因为JVM通常在单独的低优先级线程中完成finalize的执行
对象再生问题：finalize方法中，可将待回收对象赋值给GC Roots可达的对象引用，从而达到对象再生的目的
finalize方法至多由GC执行一次(用户当然可以手动调用对象的finalize方法，但并不影响GC对finalize的行为)

3. finalize的执行过程(生命周期)

finalize流程：
当对象变成GC Roots不可达时，GC会判断该对象是否覆盖了finalize方法。若未覆盖，则直接回收该对象；若已覆盖，但对象尚未被执行过finalize方法，则将该对象放入F-Queue队列中，待低优先级线程执行该队列中对象的finalize方法。执行完finalize方法后，GC会再次判断该对象是否可达。若不可达，则进行回收；否则，对象“复活”。
finalize具体流程：
对象存在两种状态，分别涉及两类状态空间，即：
- 终结状态空间 F = {未终结(finalizable), 完成终结(finalized), 未涉及(unfinalized)}
- 可达状态空间 R = {可达(reachable), 经finalizer可达(finalizer-reachable), 不可达(unreachable)}
  当对象变为不可达时，GC首先判断对象是否覆盖了finalize方法，若未覆盖，则直接回收该对象。反之，若覆盖，则将该对象置于未终结状态。该对象随后会被放入F-Queue队列中去等待执行finalize方法。在执行完成finalize方法后，JVM会在F-Queue队列中重新确定该对象的状态。若对象经过finalize方法后仍不可达，则直接进行回收；若对象经过finalize方法后重新变为可达，则对象“复活”，且相应的状态也将随之变化。

finalize方法的使用总结：

经验：尽量避免使用finalize方法，因为该方法的使用可能造成错误，并且finalize方法的执行时间不确定，会影响系统的性能。
finalize方法的优先级较低，JVM可能随时进行垃圾回收，并且finalize方法并不是在对象变成不可达时立即执行，而是在将其置于F-Queue队列之后才会被执行，因此finalize方法的执行时间是难以确定的。
若确实需要使用finalize方法来释放资源，则可以考虑使用try-catch-finally语句块来代替finalize方法。在该语句块的finally语句中释放资源，即使对象没有被垃圾回收，也能保证资源的释放。

JMM

总的来说，就是保证共享变量进行加锁保证数据的一致性。

什么是JMM?

JMM是Java内存模型(Java Memory Model)的简称，是Java虚拟机规范定义的一种内存模型。

JMM定义了Java程序中多线程访问共享变量(即多线程并发)时，访问和修改变量的行为规则，保证了程序的可见性、有序性和原子性。简单地说，JMM保证了多线程程序中的线程之间的可见性和协作。

JMM中定义的内存屏障，可以保证线程之间的同步和内存可见性。内存屏障包括了读屏障、写屏障和禁止重排序屏障等，这些屏障的作用是保证程序执行的有序性和正确性。

在Java程序中，变量的访问和修改操作，包含了读操作和写操作。而JMM定义了当多个线程同时对同一个变量进行读写操作时，对于这些操作的内存可见性、执行顺序和公平性的一些规则。

如何处理竞态问题，在Java中锁的实现，以及锁对JMM的影响，JMM在多都与其密不可分。