JVM快速入门

JVM定义：

Java Virtual Machine - java 程序的运行环境（java 二进制字节码的运行环境）
是java程序实现跨平台的⼀个重要的⼯具

栈、本地方法栈、程序计数器不会发生gc。
jvm调优主要在堆，方法区有一小部分。

常见的几种jvm

• HotSpot （我们一般使用的）

• JRockit BEA

• J9 vm IBM

JDK，JRE，JVM区别

说明：

三者关系： JDK > JRE > JVM

类加载过程

⼀个类被加载进JVM中要经历哪⼏个过程

加载： 通过io流的⽅式把字节码⽂件读⼊到jvm中（⽅法区）
校验：通过校验字节码⽂件的头8位的16进制是否是cafebabe
准备：为类中的静态部分开辟空间并赋初始化值
解析：将符号引⽤转换成直接引⽤。——静态链接
初始化：为类中的静态部分赋指定值并执⾏静态代码块。
类被加载后，类中的类型信息、⽅法信息、属性信息、运⾏时常量池、类加载器的引⽤等信息会被加载到元空间中。

类加载器

作用

加载.class文件

新建的对象放入堆里面，引用（地址）放到栈，其中引用指向堆里面对应的对象。

加载器分类

1）虚拟机自带的加载器
2）启动类（根）加载器 Bootstrap ClassLoader
3）扩展类加载器 Extension ClassLoader
4）应用程序（系统类）加载器 Application ClassLoader

• Bootstrap ClassLoader 启动类加载器：负载加载jre/lib下的核⼼类库中的类，⽐如rt.jar、charsets.jar
• ExtClassLoader 扩展类加载器：负载加载jre/lib下的ext⽬录内的类
• AppClassLoader 应⽤类加载器：负载加载⽤户⾃⼰写的类
• ⾃定义类加载器：⾃⼰定义的类加载器，可以打破双亲委派机制

双亲委派机制

检查顺序从下至上，加载顺序从上到下。

如果一个类加载器需要加载类，那么首先它会把这个类请求委派给父类加载器去完成，每一层都是如此。一直递归到顶层，当父加载器无法完成这个请求时，子类才会尝试去加载，直到找不到为⽌，则报类找不到的异常。

好处

可以避免重复加载，父类已经加载了，子类就不需要再次加载

更加安全，防⽌核⼼类库中的类被随意篡改，很好的解决了各个类加载器的基础类的统一问题，如果不使用该种方式，那么用户可以随意定义类加载器来加载核心api，会带来相关隐患

全盘委托机制

当⼀个类被当前的ClassLoader加载时，该类中的其他类也会被当前该ClassLoader加载。除⾮指明其他由其他类加载器加载。

运行时数据区

程序计数器

Program Counter Register 程序计数器（寄存器）

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

作用

是记住下一条jvm指令的执行地址

特点

是线程私有的
不会存在内存溢出

本地方法栈 Native Method Stack

它的具体做法是Native Method Stack中登记native方法，在( Execution Engine )执行引擎执行的时候加载Native Libraies。[本地库]

Native

native :凡是带了native关键字的，说明java的作用范围达不到了，回去调用底层c语言的库
会进入本地方法栈 去调用本地方法接口将native方法引入执行
调用本地方法本地接口 JNI (Java Native Interface)
JNI作用:开拓Java的使用，融合不同的编程语言为Java所用
Java诞生的时候C、C++横行，想要立足，必须要有调用C、C++的程序
private native void start0();

方法区 Method Area

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

栈stack

线程栈：执⾏⼀个⽅法就会在线程栈中创建⼀个栈帧。

栈帧包含如下四个内容：
局部变量表：存放⽅法中的局部变量
操作数栈：⽤来存放⽅法中要操作的数据
动态链接：存放⽅法名和⽅法内容的映射关系，通过⽅法名找到⽅法内容
⽅法出⼝：记录⽅法执⾏完后调⽤次⽅法的位置。

栈:先进后出,栈内存主管程序的运行,生命周期和线程同步,线程结束,栈内存也就是释放,对于栈来说,不存在垃圾回收问题,一旦线程结束,栈就结束.
栈内存中运行:8大基本类型+对象引用+实例的方法.
栈运行原理:栈桢
栈满了:StackOverflowError
队列:先进先出(FIFO:First Input First Output)

堆

一个JVM只有一个堆内存,堆内存的大小是可以调节的.类加载器读取类文件后,一般会把类,方法,常量,变量,保存我们所有引用类型的真实对象.

堆内存细分为三个区域:

新生区(伊甸园区):Young/New
养老区old
永久区Perm

新生区

目的:控制对象的诞生,成长和死亡

分为:

伊甸园区:所有对象都在伊甸园区new出来

幸存0去和幸存1区:轻GC之后存下来的

老年区

永久存在的对象放在老年区,真理:经过研究，99%的对象都是临时对象!

步骤:

当伊甸园区满了之后进行轻GC幸存下来的放到幸存0区或幸存1区
当伊甸园区,幸存0区和幸存1区都满了进行重GC,幸存下来的放到养老区
当伊甸园区,幸存0区和幸存1区和养老区都满了,会出现OOM

永久区（元空间）

元空间使用的是直接内存，与新生代和老年代分开。

堆内存调优

OOM：

1. 尝试扩大堆内存看结果
2. 分析内存，看一下哪个地方出了问题（专业工具）
   Xms1024m Xmx1024m -XX:+PrintGCDetails
3. 在一个项目中，突然出现了OOM故障，那么该如何排除？研究为什么出错
   jprofiler作用：
   1）分析dump内存文件，快速定位内存泄露
   2）获得堆中的数据
   3）获得大的对象

垃圾回收机制GC

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

GC算法

1. 引用计数法（Java没有采用）

2. 标记-清除法 （jvm老年代回收）

3. 标记-压缩法 （jvm老年代回收）

4. 复制算法 （jvm新生代回收）

引用计数法

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

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

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

循环依赖问题：
A a = new A()
B b = new B()
a.x=b
b.x=a
a=null
b=null
很难判断 然后 怎么去标记为0 去回收

根搜索算法

根搜索算法。它的处理方式就是，设立若干种根对象，当任何一个根对象到某一个对象均不可达时，则认为这个对象是可以被回收的。

ObjectD和ObjectE是互相关联的，但是由于GC roots到这两个对象不可达，所以最终D和E还是会被当做GC的对象，上图若是采用引用计数法，则A-E五个对象都不会被回收。

说到GC roots（GC根），在JAVA语言中，可以当做GC roots的对象有以下几种：

1、虚拟机栈中的引用的对象。
2、方法区中的类静态属性引用的对象。
3、方法区中的常量引用的对象。
4、本地方法栈中JNI的引用的对象。
第一和第四种都是指的方法的本地变量表，第二种表达的意思比较清晰，第三种主要指的是声明为final的常量值。

复制算法

GC 复制算法是利用 From 空间进行分配的。当 From 空间被完全占满时，GC 会将存活
对象全部复制到 To 空间，并且年龄加一。当复制完成后，该算法会把 From 空间和 To 空间互换，GC 也就结束了。From 空间和 To 空间大小必须一致。这是为了保证能把 From 空间中的所有活动对象
都收纳到 To 空间里

• 不适用于存活对象较多的场合，如老年代（复制算法适合做新生代的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），然后进行两项工作，第一项则是标记，第二项则是清除。

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

优点:不需要额外的空间

缺点:两次扫描严重浪费时间,并且还会产生内存碎片，（内存碎片会导致明明有空间，但是无法存储大对象）

标记-整理

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

优点 不会产生内存碎片
缺点 效率低

总结

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

分代收集算法

堆空间被分成了新⽣代（1/3）和⽼年代（2/3），新⽣代中被分成了eden（8/10）、
survivor1(1/10)、survivor2(1/10)
对象的创建在eden，如果放不下则触发minor gc
对象经过⼀次minorgc 后存活的对象会被放⼊到survivor区，并且年龄+1
survivor区执⾏的复制算法，当对象年龄到达15.进⼊到⽼年代。
如果⽼年代放满。就会触发Full GC

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

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

对象进入到老年代的条件

1. ⼤对象直接进⼊到⽼年代：⼤对象可以通过参数设置⼤⼩，多⼤的对象被认为是⼤对象。
   -XX:PretenureSizeThreshold
2. 当对象的年龄到达15岁时将进⼊到⽼年代，这个年龄可以通过这个参数设置：
   -XX:MaxTenuringThreshold
3. 根据对象动态年龄判断，如果s区中的对象总和超过了s区中的50%，那么下⼀次做复制的
   时候，把年龄⼤于等于这次最⼤年龄的对象都⼀次性全部放⼊到⽼年代。
4. ⽼年代空间分配担保机制 ：在minor gc时，检查⽼年代剩余可⽤空间是否⼤于年轻代⾥现有的所有对象（包含垃圾）。如果⼤于等于，则做minor gc。如果⼩于，看下是否配置了担保参数的配置：-XX: -HandlePromotionFailure ，如果配置了，那么判断⽼年代剩余的空间是否⼩于历史每次minor gc 后进⼊⽼年代的对象的平均⼤⼩。如果是，则直接full gc，减少⼀次minor gc。如果不是，执⾏minor gc。如果没有担保机制，直接fullgc

对象中的finalize⽅法

Object类中有⼀个finalize⽅法，也就是说任何⼀个对象都有finalize⽅法。这个⽅法是对象被回收之前的最后⼀根救命稻草。

• GC在垃圾对象回收之前，先标记垃圾对象，被标记的对象的finalize⽅法将被调⽤
• 调⽤finalize⽅法如果对象被引⽤，那么第⼆次标记该对象，被标记的对象将移除出即将被回收的集合，继续存活
• 调⽤finalize⽅法如果对象没有被引⽤，那么将会被回收
• 注意，finalize⽅法只会被调⽤⼀次

对象的逃逸分析

在jdk1.7之前，对象的创建都是在堆空间中创建，但是会有个问题，⽅法中的未被外部访问的对象

public void test1() {
     
  User user = new User();
  user.setId(1);
  user.setName("xiaoming");
}
public User test2() {
     
 User user = new User();
 user.setId(1);
 user.setName("xiaoming");
 return user;
}

这种对象没有被外部访问，且在堆空间上频繁创建，当⽅法结束，需要被gc，浪费了性能。所以在1.7之后，就会进⾏⼀次逃逸分析（默认开启），于是这样的对象就直接在栈上创建，随着⽅法的出栈⽽被销毁，不需要进⾏gc。

在栈上分配内存的时候：会把聚合量替换成标量，来减少栈空间的开销，也为了防⽌栈上没有⾜够连续的空间直接存放对象。

• 标量：java中的基本数据类型（不可再分）
• 聚合量：引⽤数据类型。

标量就是不可分割的量，java中基本数据类型是标量。相对的一个数据可以继续分解，它就是聚合量（aggregate）。
如果把一个对象拆散，将其成员变量恢复到基本类型来访问就叫做标量替换。
如果逃逸分析证明一个对象不会被外部访问，并且这个对象可以被拆散的话，那么程序真正执行的时候将可能不创建这个对象，而改为直接在>栈上创建若干个成员变量