面试高频！JVM必备教程~

亦凉 2023-03-04 10:25 15阅读 0赞

>  *  请你谈谈你对JVM的理解？Java8虚拟机和之间的变化更新？
>  *  JVM类加载器是怎么样的？有几种？
>  *  什么是OOM，什么是StackOverFlowError? 怎么分析？
>  *  JVM常用调优参数有哪写？
>  *  GC有几种算法？分别是怎么执行的？
>  *  内存快照如何抓取，怎么分析Dump文件？

### 目录 ###

*  一、简介
 *   *  1. 什么是JVM
     *  2. JVM的位置
     *  3. JVM、JRE、JDK 的关系
     *  4. 三种JVM
 *  二、JVM体系结构
 *  三、类加载器
 *   *  1. 作用
     *  2. 回顾new对象的过程
     *  3. 类加载器的等级
     *   *  1. 启动类(根)加载器
         *  2. 拓展类加载器
         *  3. 应用程序加载器
         *  4. 用户自定义类加载器
     *  4. 类加载机制
     *   *  1. 什么是双亲委派机制
         *  2. 为什么要设计这种机制
         *  3. 双亲委派机制的作用
     *  拓展：沙箱安全机制
     *   *  什么是沙箱？
         *  Java中的安全模型演进
         *  组成沙箱的基本组件
 *  四、本地方法接口
 *  五、PC寄存器
 *  六、方法区
 *   *  1. 方法区中有啥
     *  2. 创建对象内存分析
 *  七、栈
 *   *  1、栈中存放啥？
     *  2、栈运行原理
     *  3、堆栈溢出StackOverflowError
 *  八、堆
 *   *  1. 堆的分区图
     *  2. 堆内存详解
     *   *  Young 年轻代
         *  Tenured 老年代
         *  Perm 元空间
     *  3. GC垃圾回收
     *  4. 堆内存调优
     *   *  1. 查看并设置JVM堆内存
         *  2. 什么是OOM
         *  3. 怎么排除OOM错误？
         *   *  1. 尝试扩大堆内存看结果
             *  2. 利用内存快照工具JProfiler
             *  3. 什么是Dump文件？如何分析？
         *  附：安装Jprofiler教程
         *   *  1. idea中安装插件
             *  2. 下载客户端
             *  3. 安装客户端
             *  4. IDEA中设置
 *  九、GC算法
 *   *  1. 引用计数算法（很少使用）
     *  2. 复制算法
     *  3. 标记–清除算法
     *  4. 标记–压缩算法
     *  总结

--------------------

# 一、简介 #

## 1. 什么是JVM ##

> JVM是`Java Virtual Machine`（Java[虚拟机][Link 1]）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。

百度的解释云里雾里，对于我们Java程序员，说白了就是：

*  JVM本质上是一个`程序/软件`，它能识别`.class` 字节码文件（里面存放的是我们对`.java`编译后产生的二进制代码），并且能够解析它的指令，最终调用操作系统上的函数，完成我们想要的操作！
 *  关于Java语言的`跨平台性`，就是因为JVM，我们可以将其想象为一个抽象层，只要这个抽象层JVM正确执行了`.class`文件，就能运行在各种操作系统之上了！这就是`一次编译，多次运行`

--------------------

## 2. JVM的位置 ##

JVM是运行在操作系统之上的，与硬件没有直接的交互

![image-20200802133302669][]

--------------------

## 3. JVM、JRE、JDK 的关系 ##

> JDK（Java Development Kit）：Java开发工具包

> JRE（Java Runtime Environment）：Java运行环境

JDK = JRE + javac/java/jar 等指令工具

JRE = JVM + Java基本类库

![image-20200802140843921][]

## 4. 三种JVM ##

*  Sun公司 `HotSpot`（我们都用的这个）  
    ![image-20200802105730989.png][]
 *  BEA公司 `JRockit`
 *  IBM公司 `J9 VM`

--------------------

# 二、JVM体系结构 #

> Java虚拟机主要分为五大模块：
> 
>  *  类装载器子系统
>  *  运行时数据区
>  *  执行引擎
>  *  本地方法接口
>  *  垃圾收集模块
> 
> ![image-20200802154319450][]

*  方法区是一种特殊的堆
 *  栈里面不会有垃圾，用完就弹出了，否则阻塞了main方法
 *  垃圾几乎都在堆里，所以JVM性能调优%99都针对于堆和方法区，主要是堆

**详细图**：  
![img][]

--------------------

# 三、类加载器 #

## 1. 作用 ##

> `Class Loader` 类加载器：加载`.class`文件
> 
> ![image-20210316223145616][]  
> ![image-20210316222046713][]

1.  **加载**：加载`.Class`字节码文件加载到内存中，创建代表这个类的`java.lang.Class`对象
2.  **链接**：对类进行链接，将类的二进制代码合并到Java运行时环境`JRE`中
3.  **初始化**：然后交给`JVM`对类进行初始化

**详细过程图示**：  
![image-20210316223006506][]

--------------------

## 2. 回顾new对象的过程 ##

public class Student { 
        //私有属性
        private String name;
    
        //构造方法
        public Student(String name) { 
            this.name = name;
        }
    }

*  类是模板、模板是抽象的；对象是具体的，是对抽象的实例化

//运行时,JVM将Test的信息放入方法区
    public class Test{ 
        //main方法本身放入方法区
    	public static void main(String[] args){ 
            //s1、s2、s3为不同对象
            Student s1 = new Student("zsr");	//引用放在栈里，具体的实例放在堆里
            Student s2 = new Student("gcc");
            Student s3 = new Student("BareTH");
            System.out.println(s1.hashCode());
            System.out.println(s2.hashCode());
            System.out.println(s3.hashCode());
            //class1、class2、class3为同一个对象
            Class<? extends Student> class1 = s1.getClass();
            Class<? extends Student> class2 = s2.getClass();
            Class<? extends Student> class3 = s3.getClass();
            System.out.println(class1.hashCode());
            System.out.println(class2.hashCode());
            System.out.println(class3.hashCode());
        }
    }

根据结果，我们发现：

*  s1、s2、s3的hashcode是不同的，因为是三个不同的对象，对象是具体的
 *  class1、class2、class3的hashcode是相同的，因为这是类模板，模板是抽象的

我们画图分析以下new一个对象的流程：

1.  首先`Class Loader`读取字节码Student类编译生成的`.class`文件，加载初始化生成`Student模板类`也就是相应的`java.lang.Class`对象
2.  然后通过该`Student模板类`创建出三个具体的实例对象s1、s2、s3，这三个对象的引用在`栈`中，具体的实例是在`堆`中

![image-20200801191801450][]  
![image-20210316224242698][]

--------------------

## 3. 类加载器的等级 ##

我们编写这样一个程序，输出当前的类以及其父类往上的加载器  
![image-20200801201223277][]  
根据返回结果，可以看到不同等级的加载器，接下来介绍这些不同等级的类加载器

### 1. 启动类(根)加载器 ###

> 启动类/根加载器：`BootstrapClassLoader`

*  `c++`编写，用于加载 java核心库 `java.*`，构造 **拓展类加载器** 和 **应用程序加载器**
 *  **根加载器** 加载 **拓展类加载器**，并且将 **拓展类加载器** 的父加载器设置为 **根加载器**，
    
    然后再加载 **应用程序加载器**，应将 **应用程序加载器** 的父加载器设置为 **拓展类加载器**
 *  由于引导类加载器涉及到虚拟机本地实现细节，我们无法直接获取到启动类加载器的引用；这就是上面那个程序我们第三个结果为`null`的原因。
 *  加载文件存在位置`rt.jar`：Java基础类库，也就是Java doc里面看到的所有的类的class文件  
    ![image-20200801201827272][]

### 2. 拓展类加载器 ###

> 拓展类加载器：`PlatformClassLoader`

*  `java`编写，加载扩展库，开发者可以直接使用标准扩展类加载器。
 *  java9之前为`ExtClassloader`，Java9以后改名为`PlatformClassLoader`
 *  加载文件存在位置：`/jre/lib/ext/*.jar`
    
    ![image-20200801201942721][]

### 3. 应用程序加载器 ###

> 应用程序加载器：`AppClassLoader`

*  `java`编写，加载程序所在的目录下的类，也就是ClassPath路径下的类包
 *  是Java`默认`的类加载器

### 4. 用户自定义类加载器 ###

> 用户自定义类加载器：`CustomClassLoader`

*  开发人员可以通过继承 `java.lang.ClassLoader`类的方式实现自己的类加载器，以满足一些特殊的需求

--------------------

## 4. 类加载机制 ##

> 类加载器通过 双亲委派机制 交给其他加载器来加载指定的类

### 1. 什么是双亲委派机制 ###

我们查看“java.lang”包下的**ClassLoader**类，找到其中的**loadClass**方法

public Class<?> loadClass(String name) throws ClassNotFoundException { 
        return loadClass(name, false);
    }
    
    protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    { 
        synchronized (getClassLoadingLock(name)) { 
            // // 首先，检查是否已经被类加载器加载过
            Class<?> c = findLoadedClass(name);
            if (c == null) { 
                long t0 = System.nanoTime();
                try { 
                    // 存在父加载器，递归的交由父加载器加载
                    if (parent != null) { 
                        c = parent.loadClass(name, false);
                    } else { 
                        // 直到最上面的Bootstrap类加载器
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) { 
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }
    
                if (c == null) { 
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    c = findClass(name);
    
                    // this is the defining class loader; record the stats
                    PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) { 
                resolveClass(c);
            }
            return c;
        }
    }

这段源码很清晰的解释了**双亲委派机制**，下图就是该过程的描述  
![image-20210424172312780][]

当一个.class文件要被加载时，不考虑我们自定义类加载器类，首先会在`AppClassLoader`中**检查是否加载过**，如果有那就无需再加载；如果没有会交到**父加载器**，然后调用父加载器的**loadClass**方法。父加载器同样也会先检查自己是否已经加载过，如果没有再往上，直到到达`BootstrapClassLoader`之前，都是在检查是否加载过，并不会选择自己去加载。到了根加载器时，才会开始检查是否能够加载当前类，能加载就结束，使用当前的加载器；否则就通知子加载器进行加载；子加载器重复该步骤。如果到最底层还不能加载，就抛出异常`ClassNotFoundException`

**总结**：所有的加载请求都会传送到根加载器去加载，只有当父加载器无法加载时，子类加载器才会去加载

### 2. 为什么要设计这种机制 ###

> 这种设计有个好处是，如果有人想替换**系统级别的类**：String.java。篡改它的实现，在这种机制下这些系统的类已经被`BootstrapClassLoader`加载过了，所以其他类加载器并没有机会再去加载，从一定程度上防止了危险代码的植入。

**测试一下**：我们重写java.lang包下的String类，然后实例化出一个`String`对象进行测试  
![image-20210317104323203][]  
发现报错了，这就是双亲委派机制作用，当我们实例化出一个`String`的对象时，类加载器收到`String`类加载的请求将这个请求向上委托给父类加载器去完成，从应用程序加载器向上委托到拓展类加载器，直到根加载器，发现根加载器中已经加载过`String`类（也就是`rt.jar`中的`java.lang.String`），于事就结束了，不会再向下加载，也就是这里的`String`不是当前应用我们写的类，就不会执行我们编写的这个String类，因此报错

### 3. 双亲委派机制的作用 ###

1️⃣ **避免类的重复加载**

通过不断委托父加载器直到根加载器进行加载，如果父加载器加载过了，子加载器就不用再加载

2️⃣ **保证Java核心库类型的安全**

如保证了上述的`java.lang.String`类不能被篡改

--------------------

## 拓展：沙箱安全机制 ##

> 这里引用了这篇博文[https://www.cnblogs.com/zhahu/p/12576351.html][https_www.cnblogs.com_zhahu_p_12576351.html]，了解即可

### 什么是沙箱？ ###

> Java安全模型的核心就是Java`沙箱`（sandbox）

*  沙箱是一个限制程序运行的环境。沙箱机制就是将 Java 代码限定在虚拟机(JVM)特定的运行范围中，并且严格限制代码对本地系统资源访问，通过这样的措施来保证对代码的有效隔离，防止对本地系统造成破坏。
 *  沙箱主要限制系统资源访问，系统资源包括CPU、内存、文件系统、网络。不同级别的沙箱对这些资源访问的限制也可以不一样。

所有的Java程序运行都可以指定沙箱，可以定制安全策略。

### Java中的安全模型演进 ###

在Java中将执行程序分成`本地代码`和`远程代码`两种

*  本地代码`可信任`，可以访问一切本地资源。
 *  远程代码`不可信任`，在早期的Java实现中，安全依赖于沙箱 (Sandbox) 机制。

![img][img 1]

如此严格的安全机制也给程序的功能扩展带来障碍，比如当用户希望远程代码访问本地系统的文件时候，就无法实现。

因此在后续的 `Java1.1` 版本中，针对安全机制做了改进，增加了`安全策略`，允许用户指定代码对本地资源的访问权限。

![332636af668c3ecced801514f5b9c732.gif][]

在`Java1.2`版本中，再次改进了安全机制，增加了`代码签名`。

*  不论本地代码或是远程代码，都会按照用户的安全策略设定，由类加载器加载到虚拟机中权限不同的运行空间，来实现差异化的代码执行权限控制。

![JDK1.2安全模型][JDK1.2]

当前最新的安全机制实现，则引入了`域 (Domain)` 的概念。

*  虚拟机会把所有代码加载到不同的`系统域`和`应用域`
 *  `系统域`部分专门负责与关键资源进行交互
 *  `应用域`部分则通过系统域的部分代理来对各种需要的资源进行访问。
 *  虚拟机中不同的受保护域 (Protected Domain)，对应不一样的权限 (Permission)。存在于不同域中的类文件就具有了当前域的全部权限下

![最新的安全模型][1654b05ee8f34f808e5e3b9184a318ed.gif]

### 组成沙箱的基本组件 ###

**1. 字节码校验器`bytecode verifier`**

> 确保Java类文件遵循Java语言规范。这样可以帮助Java程序实现内存保护。但并不是所有的类文件都会经过字节码校验，比如核心类（如上述java.lang.String）。

**2. 类装载器`class loader`**

> 类装载器在3个方面对Java沙箱起作用
> 
>  *  它防止恶意代码去干涉善意的代码；
>  *  它守护了被信任的类库边界；
>  *  它将代码归入保护域，确定了代码可以进行哪些操作。
> 
> 虚拟机为不同的类加载器载入的类提供不同的命名空间，命名空间由一系列唯一的名称组成，每一个被装载的类将有一个名字，这个命名空间是由Java虚拟机为每一个类装载器维护的，它们互相之间甚至不可见。
> 
> 类装载器采用的机制是双亲委派模式
> 
> 1.  从最内层JVM自带类加载器开始加载，外层恶意同名类得不到加载从而无法使用；
> 2.  由于严格通过包来区分了访问域，外层恶意的类通过内置代码也无法获得权限访问到内层类，破坏代码就自然无法生效。
> 
>  *  `存取控制器`（access controller）：存取控制器可以控制核心API对操作系统的存取权限，而这个控制的策略设定，可以由用户指定。
>  *  `安全管理器`（security manager）：是核心API和操作系统之间的主要接口。实现权限控制，比存取控制器优先级高。
>  *  `安全软件包`（security package）：java.security下的类和扩展包下的类，允许用户为自己的应用增加新的安全特性，包括：
>     
>     1.  安全提供者
>     2.  消息摘要
>     3.  数字签名
>     4.  加密
>     5.  鉴别

--------------------

# 四、本地方法接口 #

> `JNI`：`Java Native Interface`，本地方法接口
> 
> ![image-20200801214515097][]

Java诞生的时候C/C++横行，为了立足，必须要能调用C/C++的程序；于是在内存区域中专门开辟了一块标记区域：`Native Method Stack`，登记所有的native本地方法（只是登记并不能执行）；

什么是**本地方法**呢？

>  *  本地方法是由其它语言编写的，编译成和处理器相关的机器代码。
>  *  本地方法保存在动态链接库中，即.dll(windows系统)文件中，格式是各个平台专有的。
>  *  通过本地方法，JAVA程序可以直接访问底层操作系统的资源，但是这样用，java程序就变成平台相关了，
> 
> 因为本地方法的动态库是与平台相关的，此外使用本地方法还可能把程序变得和特定的JAVA平台实现相关。

为了调用这些本地方法，就出现了`JNI`，让Java可以在执行引擎执行的的时候通过`JNI`加载本地方法库的方法，实现了与操作系统的交互

在多线程学习的时候，我们启动一个线程调用`start()`方法本质上是调用了`start0`本地方法

![image-20210317111826311][]

private native void start0();

可以看到`start0()`是用native关键字修饰的，那么`native`关键字是什么意思呢？

凡是带native关键字的，说明java的作用范围达不到了，会去调用底层本地方法库！通过`本地方法接口JNI`调用本地方法，拓展Java的使用，融合不同的语言为Java所用

> 目前该方法使用的越来越少了，除非是与硬件有关的应用，比如通过Java程序驱动打印机或者Java系统管理生产设备，在企业级应用中已经比较少见。因为现在的异构领域间通信很发达，比如可以使用 Socket通信，也可以使用 Web service等等，了解即可！

--------------------

# 五、PC寄存器 #

> **程序计数器**：`Program Counter Register`

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

--------------------

# 六、方法区 #

> **方法区**：`Method Area`

*  方法区是被`所有线程共享`，所有字段和方法字节码，以及一些特殊方法，如构造函数，接口代码也在此定义
 *  简单说，所有定义的方法的信息都保存在该区域，此区域属于`共享区间`；
 *  方法区与Java堆一样，是**各个线程共享的内存区域**，用于存储已被**虚拟机加载的类信息**、**常量**、**静态变量**、**即时编译器编译后的代码**等数据。
 *  虽然Java 虚拟机规范把**方法区描述为堆的一个逻辑部分**，但是它却有一个别名叫做`Non-Heap(非堆)`，目的应该是与Java 堆区分开来

## 1. 方法区中有啥 ##

1.  静态变量(static)
2.  类的抽象模板Class信息（版本、字段、方法、接口等描述信息，也就是Class对象）
3.  运行时常量池

**注意**：实例变量在堆内存中，与方法区无关

## 2. 创建对象内存分析 ##

![image-20200802091737843][] ![image-20200802092913288][]

*  创建一个对象时，方法区中会生成对应类的抽象模板；还有对应的常量池、静态变量、类信息、常量
 *  我们通过类模板去new对象的时候
    
     *  堆中存放实例对象
     *  栈中存放对象的引用，每个对象对应一个地址指向堆中相同地址的实例对象

例如这个例子中，生成了对应的Person模板类，name常量“zsr”放在常量池中，三个对象的引用放在栈中，该引用指向放在堆中的三个实例对象。这就是堆、栈、方法区的交互关系

--------------------

# 七、栈 #

> 又称`栈内存`，主管程序的运行，生命周期和线程同步

*  栈是线程级的：线程结束，栈内存就释放了，**不存在垃圾回收**
 *  先进后出

## 1、栈中存放啥？ ##

1.  8大基本类型
2.  对象引用
3.  实例的方法

## 2、栈运行原理 ##

*  栈表示Java方法执行的内存模型
 *  每调用一个方法就会为每个方法生成一个`栈帧（Stack Frame）`，每个方法被调用和完成的过程，都对应一个栈帧从虚拟机栈上入栈和出栈的过程。
 *  程序正在执行的方法一定在栈的顶部

![image-20200802105127681][]

## 3、堆栈溢出StackOverflowError ##

举个例子：

public class Test { 
        public static void main(String[] args) { 
            new Test().a();
        }
    
        public void a() { 
            b();
        }
    
        public void b() { 
            a();
        }
    }

最开始，main()方法压入栈中，然后执行a()，a()压入栈中；再调用b()，b()压入栈中；以此往复，a与b方法不断被压入栈中，最终导致栈溢出  
![image-20200802175751568][]  
![image-20200802100238868][]

--------------------

# 八、堆 #

> `Heap`，堆在JVM启动的时候创建，其空间大小也被创建，堆内存的大小是可以调节的；
> 
> 不同于栈：
> 
>  *  **一个JVM只有一个堆内存**，而栈是线程级的
>  *  垃圾几乎都在堆里，所以JVM性能调优%99都针对于堆和方法区，主要是堆
> 
> 堆中存放什么：
> 
>  *  **类的实例化对象**

## 1. 堆的分区图 ##

![image-20200803130536438][]

## 2. 堆内存详解 ##

![image-20210317161606676][]  
![image-20210317163956386][]

### Young 年轻代 ###

> 对象诞生、成长甚至死亡的区，分为 **伊甸园区** 和 **幸存区**

*  `Eden Space伊甸园区`：所有的对象都是在此new出来的
 *  `Survivor Space幸存区`
    
     *  `幸存0区`（`From Space`）
     *  `幸存1区`（`To Space`）
     *  这两个区是动态的，会互相交换

Eden区占大容量，Survivor两个区占小容量，默认比例是`8:1:1`。

--------------------

### Tenured 老年代 ###

在 **年轻代** 存活下来的 进入 **老年代**

--------------------

### Perm 元空间 ###

> 存储的是Java运行时的一些环境或类信息，这个区域不存在垃圾回收！关闭虚拟机就会释放这个区域内存！方法区在此

*  这个区域常驻内存，用来存放JDK自身携带的Class对象、Interface元数据。
 *  **什么情况永久区会崩？**
    
    一个启动类加载了大量的第三方Jar包，Tomcat部署了过多应用，或者大量动态生成的反射类
    
    这些东西不断的被加载，直到内存满，就会出现`OOM`
 *  **名称演变**
    
        jdk1.6之前: `永久代`
        jdk1.7: `永久代`慢慢退化 ==> `去永久代`
        jdk1.8之后: `永久代`改名为`元空间`

注意：**元空间在逻辑上存在，在物理上不存在**

新生代 + 老年代的内存空间 = JVM分配的总内存  
![image-20200802211056044][]

--------------------

## 3. GC垃圾回收 ##

> GC垃圾回收，主要在年轻代和老年代
> 
>  *  **Minor GC**：伊甸园区满时触发；从年轻代回收内存
>  *  **Full GC**：老年代满时触发；清理整个堆空间，包含年轻代和老年代

首先，对象出生再`伊甸园区`

*  假设`伊甸园区`只能存一定数量的对象，则每当存满时就会触发一次 轻**GC(Minor GC)**
 *  **轻GC** 清理后，有的对象可能还存在引用，就活下来了，活下来的对象就进入`幸存区`；有的对象没用了，就被GC清理掉了；每次 **轻GC** 都会使得`伊甸园区`为空
 *  如果对象在`年轻代`经历了15次GC还没有死亡（可设置`-XX:MaxTenuringThreshold=n`新生代的对象最多经历n次GC， 就能晋升到老年代），则会进入`老年代`，如果`老年代`满了，就会触发一次 重**GC(FullGC)**，`年轻代+老年代`的对象都会清理一次，活下的对象就进入`老年代`
 *  如果`新生代`和`老年代`都满了，则**OOM**

[何时进入老年代][Link 2]

--------------------

## 4. 堆内存调优 ##

### 1. 查看并设置JVM堆内存 ###

查看我们jvm的`堆内存`

public class Test { 
        public static void main(String[] args) { 
            //返回jvm试图使用的最大内存
            long max = Runtime.getRuntime().maxMemory();
            //返回jvm的初始化内存总量
            long total = Runtime.getRuntime().totalMemory();
            //默认情况下：分配的总内存为电脑内存的1/4,初始化内存为电脑内存的1/64
            System.out.println("max=" + max / (double) 1024 / 1024 / 1024 + "G");
            System.out.println("total=" + total / (double) 1024 / 1024 / 1024 + "G");
        }
    }

![image-20200802203740212][]

![image-20200802203754264][]  
**默认情况下**：

*  JVM最大分配内存为电脑内存的1/4
 *  JVM初始化内存为电脑内存的1/64

> 我们可以手动调堆内存大小

![image-20200802203828544][]  
在`VM options`中可以指定`jvm试图使用的最大内存`和`jvm初始化内存`大小  
![image-20200802205748906][]

-Xms1024m -Xmx1024m -Xlog:gc*

*  `-Xmx`用来设置`jvm试图使用的最大内存`，默认为1/4
 *  `-Xms`用来设置`jvm初始化内存`，默认为1/64
 *  `-Xlog:gc*`用来打印GC垃圾回收信息

![image-20200802205834231][]

### 2. 什么是OOM ###

> `内存溢出`：java.lang.OutOfMemoryError

**产生原因**：

1.  分配的太少
2.  用的太多
3.  用完没释放

我们可以写一个实例模拟堆内存溢出

package java.lang;
    
    import java.util.Random;
    
    public class Test{ 
        public static void main(String[] args){ 
            String str = "zsr";
            while(true){ 
                str += str + new Random().nextInt(88888888)+ new Random().nextInt(888888888);
            }
        }
    }

![image-20210317161031239][]

### 3. 怎么排除OOM错误？ ###

#### 1. 尝试扩大堆内存看结果 ####

> 利用上述方法指定`jvm试图使用的最大内存`和`jvm初始化内存`大小

#### 2. 利用内存快照工具JProfiler ####

例如：MAT（Eclipse）、JProfiler

作用：分析Dump内存文件，快速定位内存泄漏；获得堆中的文件；获得大的对象…

#### 3. 什么是Dump文件？如何分析？ ####

> Dump文件是`进程`的`内存镜像`，可以把程序的`执行状态`通过调试器保存到dump文件中

**举个例子**

import java.util.ArrayList;
    
    public class Test { 
        byte[] array = new byte[1024 * 1024];//1M
    
        public static void main(String[] args) { 
            ArrayList<Test> list = new ArrayList<>();
            int count = 0;
            try { 
                while (true) { 
                    list.add(new Test());
                    count++;
                }
            } catch (Exception e) { 
                System.out.println("count=" + count);
                e.printStackTrace();
            }
        }
    }

运行该程序，报错`OOM`  
![image-20200803101511962][]  
接下来我们设置以下堆内存，并附加生成对应的`dump文件`的指令

-Xms1m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError

*  `-XX:+HeapDumpOnOutOfMemoryError`表示当JVM发生OOM时，自动生成DUMP文件。

再次点击运行，下载了对应的`Dump`文件  
![image-20200803101950485][]  
我们右键该类，点击`Show in Explorer`  
![image-20200803102029506][]  
一直点击上级目录，直到找到`.hprof`文件，与`src`同级目录下

![image-20200803102326809][] 我们双击打开，可以看到每块所占的大小，便于分析问题 !\[image-20200803103451739\](https://img-blog.csdnimg.cn/img\_convert/7946baed860b658a5e33cf8c0a64e243.png) 点击\`Thread Dump\`，里面是所有的线程，点击对应的线程可以看到相应的错误，反馈到具体的行，便于排错 !\[image-20200803103549701\](https://img-blog.csdnimg.cn/img\_convert/3bcd33d54cd1918d6d61763e0576a910.png)

每次打开Dump文件查看完后，`建议删除`，可以在idea中看到，打开文件后生成了很多内容，占内存，建议删除  
![image-20200803105321131][]

### 附：安装Jprofiler教程 ###

#### 1. idea中安装插件 ####

![image-20200802220019318][]

#### 2. 下载客户端 ####

下载地址：[https://www.ej-technologies.com/download/jprofiler/files][https_www.ej-technologies.com_download_jprofiler_files]  
![image-20200802220133541][]

#### 3. 安装客户端 ####

选择自定义安装，注意：路径不能有中文和空格  
![image-20200802221801637][]

![image-20200802222314832][] ![image-20200802224806160][] ![image-20200802224847517][]

后续默认，安装成功即可

#### 4. IDEA中设置 ####

安装完成后，重启IDEA，可以看到我们的内存快照工具  
![image-20200803100145161][]  
打开IDEA的设置，找到Tools里面的JProfiler，没有设置位置则设置位置  
![image-20200803100302668][]

此时则全部安装完成

--------------------

# 九、GC算法 #

> `Garbage Collection`：垃圾回收
> 
> ![image-20200803111122670][]
> 
> **我们已经对GC的流程进行了大概的讲解，这里做一些总结**：
> 
>  *  JVM在进行GC时，并不是对`年轻代`、`老年代`统一回收；大部分时候，回收都是在`年轻代`
>  *  **GC分为两种**：
>     
>      *  `轻GC`（清理年轻代）
>      *  `重GC`（清理年轻代+老年代）

## 1. 引用计数算法（很少使用） ##

*  每个对象在创建的时候，就给这个对象绑定一个计数器
 *  每当有一个引用指向该对象时，计数器加一；每当有一个指向它的引用被删除时，计数器减一
 *  这样，当没有引用指向该对象时，该对象死亡，计数器为0，这时就应该对这个对象进行垃圾回收操作
 *  计数器本身也是一种消耗

![image-20200803131912296][]

## 2. 复制算法 ##

**复制算法**主要发生在`年轻代`（ `幸存0区` 和 `幸存1区`）

*  当Eden区满的时候，会触发`轻GC`，每触发一次，活的对象就被转移到幸存区，死的就被GC清理掉了，所以每触发`轻GC`时，Eden区就会清空；
 *  对象被转移到了幸存区，幸存区又分为`From Space`和`To Space`，这两块区域是**动态交换**的，**谁是空的谁就是To Space**，然后`From Space`就会把全部对象转移到`To Space`去；
 *  那如果两块区域都不为空呢？这就用到了`复制算法`，其中一个区域会将存活的对象转移到令一个区域去，然后将自己区域的内存空间清空，这样该区域为空，又成为了`To Space`；
 *  所以每次触发`轻GC`后，Eden区清空，同时To区也清空了，所有的对象都在From区

> 这也就是`幸存0区`和`幸存1区`总有一块为空的原因

![image-20200803120637032][]

**好处**：没有内存的碎片（内存集中在一块）

**坏处**：

1.  浪费了内存空间（浪费了幸存区一半空间）
2.  对象存活率较高的场景下（比如老年代那样的环境），需要复制的东西太多，效率会下降。

最佳使用环境：对象存活度较低的时候，也就是`年轻代`

## 3. 标记–清除算法 ##

为每个对象存储一个标记位，记录对象的生存状态

1.  标记阶段：这个阶段内，为每个对象更新标记位，检查对象是否死亡；
2.  清除阶段：该阶段对死亡的对象进行清除，执行 GC 操作。

![image-20200803131533109][]

**缺点**：两次扫描严重浪费时间，会产生内存碎片

**优点**：不需要额外的空间

## 4. 标记–压缩算法 ##

`标记-整理法` 是 `标记-清除法` 的一个改进版。

又叫做 `标记-清除-压缩法`

1.  标记阶段，该算法也将所有对象标记为存活和死亡两种状态；
2.  不同的是，在第二个阶段，该算法并没有直接对死亡的对象进行清理，而是再次扫描，向一段移动存活的对象，然后把剩下的所有对象全部清除。

缺点：多了一次移动成本  
![image-20200803131545066][]

可以进一步优化，在**内存碎片不太多**的情况下，就继续`标记清除`，到达一定量的时候再`压缩`

## 总结 ##

*  **内存（时间复杂度）效率**：复制算法 > 标记清除算法 > 标记压缩算法
 *  **内存整齐度**：复制算法 = 标记压缩法 > 标记清除法
 *  **内存利用率**：标记压缩法 = 标记清除法 > 复制算法

**思考：有没有最优的算法？**

> 没有最优的算法，只有最合适的算法，所以 GC 也称为 `分代收集算法`，对于年轻代和老年代采用不同的算法

对于**年轻代**：

*  对象存活率低
 *  用复制算法

对于**老年代**：

*  区域大，对象存活率高
 *  用`标记清除+标记压缩`混合实现

[Link 1]: https://baike.baidu.com/item/%E8%99%9A%E6%8B%9F%E6%9C%BA
[image-20200802133302669]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200802133302669.png
[image-20200802140843921]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200802140843921.png
[image-20200802105730989.png]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200802105730989.png
[image-20200802154319450]: /images/20230208/f3ef4635cb9e476380dd2f99cd9ca1b5.png
[img]: /images/20230208/96479c4829494bf181a56d9f7400e10c.png
[image-20210316223145616]: /images/20230208/e082428d85a742c585072489348935e4.png
[image-20210316222046713]: /images/20230208/6f64634e757149f29a03df85122f66fa.png
[image-20210316223006506]: /images/20230208/d713338bbb1f40d99fd5332382fb4c92.png
[image-20200801191801450]: /images/20230208/a49a1ce6505148e5b65a9fc8c1f966f8.png
[image-20210316224242698]: /images/20230208/70d1583f195d4479a58e0dae4b0672da.png
[image-20200801201223277]: /images/20230208/5be2d937d454445cb0c1184892f37c70.png
[image-20200801201827272]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200801201827272.png
[image-20200801201942721]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200801201942721.png
[image-20210424172312780]: https://gitee.com/zhong_siru/images/raw/master//img/image-20210424172312780.png
[image-20210317104323203]: /images/20230208/4132111fe4794073a1f256a0f583fd71.png
[https_www.cnblogs.com_zhahu_p_12576351.html]: https://www.cnblogs.com/zhahu/p/12576351.html
[img 1]: /images/20230208/9abe3e32bcc349bda205cda34aa6f294.png
[332636af668c3ecced801514f5b9c732.gif]: /images/20230208/c2a66cb764c24069ad00532fce89f8ce.png
[JDK1.2]: /images/20230208/90a7238ef86b4e69b157d442b905d115.png
[1654b05ee8f34f808e5e3b9184a318ed.gif]: /images/20230208/32b41c13a0254596a427b9b498e7d274.png
[image-20200801214515097]: /images/20230208/61c0cb79bfc2451abaff3d05e73ea1f8.png
[image-20210317111826311]: /images/20230208/e45cdc1e1efd4eefa79f36bb94d7f850.png
[image-20200802091737843]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200802091737843.png
[image-20200802092913288]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200802092913288.png
[image-20200802105127681]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200802105127681.png
[image-20200802175751568]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200802175751568.png
[image-20200802100238868]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200802100238868.png
[image-20200803130536438]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200803130536438.png
[image-20210317161606676]: /images/20230208/d1635961a0754b759ff5e523a8e05d66.png
[image-20210317163956386]: /images/20230208/209927013ab74d598b3652bf66c62db6.png
[image-20200802211056044]: /images/20230208/ded02aa4a17547b1b5207fe2befabd9d.png
[Link 2]: https://my.oschina.net/u/4346331/blog/3986556
[image-20200802203740212]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200802203740212.png
[image-20200802203754264]: /images/20230208/9f1c302b10104011b7a39b8a0d65a7f2.png
[image-20200802203828544]: /images/20230208/bb0db765229546ddb28d7c07a11f82f5.png
[image-20200802205748906]: /images/20230208/38c88fc2e6944da59c58f464d2b5da6f.png
[image-20200802205834231]: /images/20230208/09f6433a668242ee963c5a9672049c24.png
[image-20210317161031239]: /images/20230208/b89fdc68f1b846578c036c428aa60486.png
[image-20200803101511962]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200803101511962.png
[image-20200803101950485]: /images/20230208/e9754a80a04a466d8b51ee1fac1579f2.png
[image-20200803102029506]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200803102029506.png
[image-20200803102326809]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200803102326809.png
[image-20200803105321131]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200803105321131.png
[image-20200802220019318]: /images/20230208/9390703663fc4acca7e410614e1d9dc7.png
[https_www.ej-technologies.com_download_jprofiler_files]: https://www.ej-technologies.com/download/jprofiler/files
[image-20200802220133541]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200802220133541.png
[image-20200802221801637]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200802221801637.png
[image-20200802222314832]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200802222314832.png
[image-20200802224806160]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200802224806160.png
[image-20200802224847517]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200802224847517.png
[image-20200803100145161]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200803100145161.png
[image-20200803100302668]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200803100302668.png
[image-20200803111122670]: /images/20230208/dc5707052e9c4c1ba91a305a39c324de.png
[image-20200803131912296]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200803131912296.png
[image-20200803120637032]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200803120637032.png
[image-20200803131533109]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200803131533109.png
[image-20200803131545066]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200803131545066.png