JVM基础篇二

三、运行时数据区

运行时数据区-总览
Java虚拟机在运行Java程序过程中管理的内存区域，称之为运行时数据区。

• 《Java虚拟机规范》中规定了每一部分的作用。
  
  运行时数据区-应用场景

面试：
Java的内存分成哪几部分？详细介绍一下吧
Java内存中哪些部分会内存溢出？
JDK7和8在内存结构上的区别是什么？

• 工作
  抛出内存溢出异常
  

1.程序计数器

• 程序计数器也叫PC寄存器，每个线程会通过程序计数器记录当前要执行的字节码指令的地址。
  
• 程序计数器的具体案例：
  
• 在加载阶段，虚拟机将字节码文件中的指令读取到内存之后，会将原文件中的偏移量转换成内存地址。每一条字节码指令都会拥有一个内存地址。
  
• 在代码执行过程中，程序计数器会记录下一行字节码指令的地址。执行完当前指令之后，虚拟机的执行引擎根据程序计数器执行下一行指令。
  
• 程序计数器可以控制程序指令的进行，实现分支、跳转、异常等逻辑。
  
• 在多线程执行情况下，Java虚拟机需要通过程序计数器记录CPU切换前解释执行到那一句并继续解释运行。

程序计数器在运行中会出现内存溢出吗？

• 内存溢出指的是程序在使用某一块内存区域时，存放的数据需要占用的内存大小超过了虚拟机能提供的内存上限。
• 因为每个线程只存储一个固定长度的内存地址，程序计数器是不会发生内存溢出的。
• 程序员无需对程序计数器做出任何处理。

2.栈

Java虚拟机采用栈的数据结构来管理方法调用中的基本数据，先进后出，每个方法的调用使用一个栈帧来保存。

通过Idea的debug工具查看栈帧的内容

Java虚拟机栈

Java虚拟机栈随着线程的创建而创建，而回收则会在线程的销毁而时而进行。由于方法可能会在不同线程中执行，每个线程都会包含一个自己的虚拟机栈。

栈帧的组成

局部变量表

• 局部变量表的作用是在方法执行过程中存放所有的局部变量。编译成字节码文件时就可以确定局部变量表的内容。
  
• 栈帧中的局部变量表是一个数组，数组中每个位置称之为槽，long和double类型占用两个槽，其他类型占用一个槽。
  
• 实例方法中的序号为0的位置存放的是this，指的是当前调用方法的对象，运行时会在内存中存放实例对象的地址。
  
• 方法参数也会保存在局部变量表中，其顺序与方法中参数定义的顺序一致。
• 局部变量表保存的内容有：实例方法的this对象，方法的参数，方法体中声明的局部变量。
  
• 为了节省空间，局部变量表中的槽是可以复用的，一旦某个局部变量不再生效，当前槽就可以再次被使用。
  

操作数栈

• 操作数栈是栈帧中虚拟机在执行指令过程中用来存放中间数据的一块区域。他是一种栈式的数据结构，如果一条指令将一个值压入操作数栈，则后面的指令可以弹出并使用该值。
• 在编译期就可以确定操作数栈的最大深度，从而执行时正确的分配内存大小。
  

帧数据

• 当前类的字节码指令引用了其他类的属性或者方法时，需要将符号引用（编号）转换成对应的运行时常量池中的内存地址。动态链接就保存了编号到运行时常量池的内存地址映射关系。
  
• 方法的出口指的是方法在正确或者异常结束时，当前栈帧会被弹出，同时程序计数器应该指向上一个栈帧中的下一条指令的地址。所以在当前栈帧中，需要存储此方法出口的地址。
  
• 异常表存放的是代码中异常的处理信息，包含了try代码块和catch代码块执行后跳转到的字节码指令的位置；
  

栈内存溢出

• Java虚拟机栈如果栈帧过多，占用内存超过栈内存可以分配的最大大小就会出现内存溢出。
• Java虚拟机栈内存溢出时会出现StackOverflowErroe的错误
  
• 虚拟机栈-默认大小
  如果不指定栈的大小，jvm将创建一个具有默认大小的栈，大小取决于曹组奥系统和计算机的体系结构。
  
• 设置大小
• 要修改Java虚拟机栈的大小，可以使用虚拟机参数 -Xss
• 语法： -Xss栈大小
• 单位：字节（默认，必须是1024的倍数）、k或者K(K8)、g或者G(GB)
  
• 注意事项
  1、与-Xss类似，可以使用-XX:ThreadStackSize调整标志来配置堆栈的大小。
  格式为：-XX:ThreadStackSize=1024
  2、HotSpot JVM对栈大小的最大值和最小值有要求：
  比如测试如下两个参数：
  -Xss1k
  -Xss1025m
  windows(64位)下的JDK8测试最小值为180k,最大值为1024m
  3、局部变量过多、操作数栈深度过大，也会影响栈内存的大小。
  一般情况下，工作中即便用了递归操作，栈的深度最多只能到几百，不会出现栈的溢出。所有此参数可以手动指定为-Xss256k节省内存。
  本地方法栈
• JAVA虚拟机栈存储了Java方法调用时的帧栈，而本地方法存储的是native本地方法的栈帧。
• 在Hotspot虚拟机中，Java虚拟机栈和本地方法栈实现使用了同一个栈空间。本地方法栈会在栈内存上生成一个栈帧，临时保存方法的参数同时方便出现异常时也会把本地方法的栈信息打印出来。
  

3.堆

Java堆

• 一般Java程序中堆内存是空间最大的一块内存区域。创建出来的对象都存在堆上。
• 栈上的局部变量表中，可以存放堆上对象的引用。静态变量也可以存放堆对象的引用，通过静态变量就可以实现对象在线程之间的共享。
  
• 堆空间有三个需要关注的值，used total max
• userd指的是当前已经使用的堆内存，total是java虚拟机已经分配的可用堆内存，max是虚拟机可以分配的最大内存
  
• arthas中堆内存相关的功能
• 堆内存used total max三个值可以通过dashboard命令看到。
• 手动指定刷新频率（不指定默认5秒一次）:dashboard -i 刷新频率（毫秒）
  
• 随着堆中的对象增多，当total可以使用的内存即将不足时，java虚拟机会继续分配内存给堆。
  
  问题：是不是当user = max = total的时候就溢出了呢
• 不是，堆内存溢出的判断条件比较复杂，在下章的《垃圾回收器》中会介绍。
• 如果不设置任何的虚拟机参数，max默认是系统内存的1/4，total默认是系统内存的1/64。实际应用中一般都需要设置total和max的值

堆-设置大小

• 要修该的堆的大小，可以使用虚拟机参数 -Xmx(max最大值)和-Xms（初始的total）

• 语法：-Xmx值 -Xms值

• 单位：字节（默认，必须是1024的倍数）、k或者K(KB)、m或者M(MB)、g或者G(GB)

• 限制:Xmx必须大于2MB，Xms必须大于1MB
  为什么arthas中显示的heap堆大小与设置的值不一样呢？
  arthas中的head堆内存使用了JMX技术中内存获取方式，这众方式与垃圾回收器有关，计算的是可以分配对象的内存，而不是整个内存。

• Java服务端程序开发时，建议将-Xmx和-Xms设置为相同的值，这样程序启动后可以使用的总内存就是最大内存，而无需向java虚拟机再次申请，减少了申请并分配内存时间上的开销，同时也不会出现内存过剩之后堆收缩的情况

• -Xmx具体设置的值与实际的应用程序运行环境有关，在《实战篇》中会给出设置方案。
  

4.方法区

• 方法区是存放基础信息的位置，线程共享，主要包含三部分内容：
  

类的元信息

• 方法区是用来存储每个类的基本信息（原信息），一般称之为InstanceKlass对象。在类的加载阶段完成。
  

运行时常量池

• 方法区除了存储类的元信息外，还存放了运行时常量池。常量池中存放的是字节码中的常量池内容。
• 字节码文件通过编号查表的方式找到常量，这种常量池称为静态常量池。当常量池加载到内存之后，可以通过内存地址快速的定位到常量池中的内容，这种常量池称为运行时常量池。
  
• 方法区是《Java虚拟机规范》中设计的虚拟概念，每款Java虚拟机在实现上都各有不同。Hotsport设计如下：
• JDK7及之前的版本将方法区存放在堆区域中的永久空间，堆的大小由虚拟机参数来控制。
• JDK8及之后的版本将方法区存放在元空间中，元空间位于操作系统维护的直接内存中，默认情况下只要不要超出操作系统承受的上限，可以一直分配。
  

方法区溢出

JDK7上运行大概十几万次就出现了错误。在JDK8上运行百万次，程序没出现任何错误 ，但是内存会直线升高。这说明JDK7和JDK8在方法区的存放上，采用了不同的设计。

• JKD7将方法区存放在堆区域中的永久代空间，堆的大小由虚拟机参数-XX:MaxPermSize=值来控制
• JDK8将方法区存放在元空间中，元空间位于操作系统维护的直接内存中，默认情况下只要不超过操作系统承受的上限，可以一直分配，可以使用-XX:MaxMetaspaceSize=值将元空间最大大小进行限制。

字符串常量池

• 方法区中除了类的元信息、运行时常量池之外，还有一块区域叫字符串常量池
• 字符串常量池存储在代码中定义的常量字符串内容。比如："123"这个123就会被放入字符串常量池。
  
  字符串常量池和运行时常量池有什么关系？
  早期设计时，字符串常量池时属于运行时常量池的一部分，他们存储的位置也是一致的。后续做出了调整，将字符串常量池和运行时常量池做了拆分。
  
  

神奇的intern

需求：

• String.intern()方法是可以手动将字符串放入字符串常量池中，分别在JDK6 JSK8下执行代码，JDK6中结果是false false,JDK8中时true false
  
  JDK版本中intern()方法会把第一次遇到的字符串实例复制到永久代的字符串常量池中，返回的也是永久代里面这个字符串实例的引用。JVM启动时就会把java加入到常量池中。
  
  JDK7及之后的版本中由于字符串常量池在堆上，所以intern()方法会把第一次遇到的字符串的引用放入字符串常量池。
  
  问题：静态变量存储在哪里？
• JDK及之前的版本中，静态变量是存放在方法区中，也就是永久代
  
• JDK7及之后的版本中，静态变量是存放在堆中的Class对象中，脱离了永久代
  

5.直接内存

• 直接内存并不在《Java虚拟机规范》中存在，所以并不属于Java运行时的内存区域。
  在JDK1.4中引用了NIO机制，使用了直接内存，主要为了解决以下两个问题：
  1、Java堆中的对象如果不再使用要回收，回收时会影响对象的创建和使用。
  2、IO操作比如读文件，需要先把文件读入直接内存（缓冲区）再把数据复制到Java堆中
  现在直接放入直接内存即可，同时Java堆上维护直接内存的引用，减少了数据复制的开销写文件也是类似的思路
  
• 要创建直接内存上的数据，可以使用ByteBuffer。
• 语法：ByteBuffer directBuffer = ByteBuffer.allocateDirect(size);
• 注意事项：arthas的memory命令可以查看直接内存大小，属性名direct。
  
• 如果需要手动调整直接内存的大小，可以使用-XX:MaxDirectMemorySize=大小
  单位k或者K表示千字节，m或M表示兆字节，g或G表示千兆字节。默认不设置该参数的情况下，JVM自动选择最大分配的大小。
  以下示例以不同的单位说明如何将直接内存大小为1024KB；
  -XX:MaxDirectMemorySize=1m
  -XX:MaxDirectMemorySize=1024k
  -XX:MaxDirectMemorySize=1048576

1.运行区数据区分成那几部分，每一部分的作用是什么？

2、不同JDK版本之间运行时数据区域的区别是什么？JDK7

JDK8

四、自动垃圾回收

C/C++的内存管理

• 在C/C++这类没有自动垃圾回收机制的语言中，一个对象如果不再使用，需要手动释放，否则就会出现内存泄漏。我们称这种释放对象的过程为垃圾回收，而需要程序员编写代码进行回收的方式为手动回收。
• 内存泄漏指的是不再使用的对象在系统中未被回收，内存泄漏的积累可能会导致内存溢出。
  

Java的内存管理

• Java中为了简化对象的释放，引入了自动的垃圾回收（Garbage Collection简称GC）机制。通过垃圾回收器来对不再使用的对象完成自动的回收，垃圾回收器主要负责对堆上的内存进行回收。其他很多现代语言比如C# 、Python、Go都拥有自己的垃圾回收器。
  

垃圾回收的对比

• 线程不共享的部分，都是伴随着线程的创建而创建，线程的销毁而销毁。而方法的栈帧在执行完方法之后就会自动弹出栈并释放掉对应的内存。
  

方法区的回收

• 方法区中能回收的内容主要就是不再使用的类。
  判定一个类可以被卸载。需要同时满足下面是三个条件：
  1、此类所有实例对象都已经被回收，在堆中不存在任何该类的实例对象以及子类对象。
  
  2、加载该类的类加载器已经被回收。
  
  3、该类对应的java.lanag.Class对象没有任何地方被引用
  
  开发中此类场景一般很少出现，主要在如OSGi、JSP的热部署等应用场景中
  每个jsp文件对应一个唯一的类加载器，当一个jsp文件修改了，就直接卸载这个jsp类加载器。重新创建类加载器，重新加载jsp文件。

手动触发回收

• 如果需要手动触发垃圾回收，可以调用System.gc()方法。
• 语法：System.gc()
• 注意事项：
  调用System.gc()方法并不一定会立即回收垃圾，仅仅是向Java虚拟机发送一个垃圾回收的请求，具体是否需要执行垃圾回收Java虚拟机会自行判断。

堆回收

如何判断堆上的对象可以回收？

Java中的对象是否能被回收，是根据对象是否被引用来决定的。如果对象被引用了，说明该对象还在使用，不允许被回收。
比如下面的代码的内存结构图：

只用无法通过引用获取到对象时，该对象才能被回收。
图中A的实例对象要回收，有两个引用要去除：
1.栈中a1变量到对象的引用 2.B对象到A对象的引用
如果在main方法中最后执行a1=null,b1=null,是否能回收A和B对象呢？
可以回收，方法中已经没有办法使用引用去访问A和B对象了

引用计数法和可达性分析法

如何判断堆上的对象有没有被引用？
常见的有两种判断方法：引用计数法和可达分析法。
引用计数法会为每个对象维护一个引用计数器，当对象被引用时加1，取消引用时减1.

引用计数法的缺点-循环引用

引用计数法的优点是实现简单，C++中智能指针就采用了引用计数法，但是它存在缺点，主要有两点：
1、每次引用和取消引用需要维护计数器，对系统性能会有一定的影响
2、存在循环引用的问题，所谓循环引用就是A引用B,B引用A，会出现对象无法回收的问题。
查看垃圾回收日志

• 如果想要查看垃圾回收的信息，可以使用-verbose:gc参数。
• 语法： -berbose:gc

可达性分析算法

Java使用的是可达性分析算法来判断对象是否可以被回收。可达性分析将对象分为两类：垃圾回收的根对象（GC Root）和普通对象，对象与对象之间存在引用关系
下图中A到B再到C和D,形成恶劣一个引用链，可达性分析算法指的是如果从某个GC Root对象是可达的，对象就不可被回收。

哪些对象被称之为GC Root对象呢？

• 线程Thread对象
  

• 系统类加载器加载的java.lang.Class对象
  

• 监视器对象，用来保存同步锁synchronized关键字持有的对象
  

• 本地方法调用时使用的全局对象

查看GC Root
通过arthas和eclipse Memory Analyze(MatT)工具可以查看GC Root,MAT工具是eclipse推出的Java堆内存检测工具。具体操作步骤如下：
1、使用arthas和heapdump命令将堆内存快照保存到本地磁盘中。
2、使用MAT工具打开堆内存快照文件。
3、选择GC Roots功能查看所有的GC Root

五种对象引用

几种常见的对象引用
可达性算法中描述的对象引用，一般指的是强引用，即是GCRoot对象对普通对象有引用关系，只要这层关系存在，普通对象就不会被回收。除了强引用之外，Java还设计了几种其他引用方式：

• 软引用
• 弱引用
• 虚引用
• 终结器引用

软引用

软引用相对于强引用是一种比较弱的引用关系，如果一个对象只有软引用关联到它，当程序内存不足时，就会将软引用中的数据进行回收。
在JDK1.2版以后提供了SoftReference类来实现软引用，软引用常用于缓存中。

软引用的执行过程如下：
1、将对象使用软引用包装起来，new SoftReference<对象类型>(对象).
2、内存不足时，虚拟机尝试进行垃圾回收
3、如果垃圾回收仍不能解决内存不足的问题，回收软引用中的对象
4、如果依然内存不足，抛出OutOfMemory异常。

问题：
当一个软引用对象的数据对象被回收时，软引用对象SoftReference也需要回收，怎样判断软引用对象是否需要回收？
SoftReference提供了一套队列机制：
1、软引用创建时，通过构造器传入引用队列
2、在软引用中包含的对象被回收时，该软引用对象会被放入引用队列
3、通过代码遍历引用队列，将SoftReference的强引用删除

 public static void main(String[] args) throws IOException {

        ArrayList<SoftReference> softReferences = new ArrayList<>();
        //用来存储没有数据对象的软引用
        ReferenceQueue<byte[]> queues = new ReferenceQueue<byte[]>();
        for (int i = 0; i < 10; i++) {
        //创建100字节的数组
            byte[] bytes = new byte[1024 * 1024 * 100];
            SoftReference studentRef = new SoftReference<byte[]>(bytes,queues);
                        softReferences.add(studentRef);
        }
        //将软引用保存起来防止软引用对象被回收
        SoftReference<byte[]> ref = null;
        int count = 0;
        //在队列中不停的弹出对象
        while ((ref = (SoftReference<byte[]>) queues.poll()) != null) {
            count++;
        }
        System.out.println(count);

    }

应用场景-缓存
软引用也可以使用继承自SoftReference类的方式来实现，StudentRef类就是一个软引用对象。
通过构造器传入软引用包含的对象，以及引用队列。

使用软引用实现学生数据的缓存

弱引用

弱引用的整体机制和软引用基本一致，区别在于弱引用包含的对象在垃圾回收时，不管内存够不够都会直接被回收。
在JDK1.2版后提供了WeakReference类来实现弱引用，弱引用主要在ThreadLocal中使用。
弱引用对象本身也可以使用引用队列进行回收。

虚引用和终结器引用

• 这两种引用在常规开发中是不会使用的。
• 虚引用也叫幽灵引用，不能通过虚引用对象获取到包含的对象。虚引用唯一的用途是当对象被垃圾回收器回收时可以接到对应用的通知。Java中使用PhantomReference实现了虚引用，直接内存为了及时知道直接内存对象不再使用，从而回收内存，使用了虚引用来实现。
• 终结器引用指的是在对象需要被回收时，对象将会被放置在Finalizer类的引用队列中，并在稍后由一条由FinalizerThread线程从队列中获取对象，然后执行对象的finalize方法。在这个过程中可以在finalize方法中再将自身对象使用强引用关联上，但是不建议这样做，如果耗时过长会影响其他对象的回收

垃圾回收算法

核心思想

• Java是如何实现垃圾回收的呢？简单来说，垃圾回收要做的有两件事：
  1、找到内存中存活的对象
  2、释放不再存活对象的内存，使得程序能再次利用这部分空间
  
  

算法的评价标准

Javal垃圾回收过程会通过单独的GC线程来完成，但是不管使用哪一种GC算法，都会有部分阶段需要停止所有的用户线程。这个过程被称之为Stop The World简称STW，如果STW时间过长则会影响用户的使用

所以判断GC算法是否优秀，可从三个方面来考虑：
1、吞吐量
吞吐量指的是CPU用于执行用户代码的时间与CPU总执行时间的比值，即吞吐量 = 执行用户代码时间 / （执行用户代码时间 + GC时间）。吞吐量数值越高，垃圾回收的效率就越高。

2.最大暂停时间
最大暂停时间指的是所有在垃圾回收过程中的STW时间最大值。比如如下的图中，黄色部分的STW就是最大暂停时间，显而易见上面的比下面的拥有更少的最大暂停时间。最大暂停时间越短，用户使用系统是收到的影响就越短。

3.堆使用效率

不同垃圾回收算法，对堆内存的使用方式是不同的。比如标记清楚算法，可以使用完整的堆内存。而复制算法会将堆内存一分为二，每次只能使用一半内存。从堆的使用效率上来说，标记清除算法要优于复制算法。
上述三种评价标准：堆使用效率、吞吐量，以及最大暂停时间不可兼得。
一般来说，堆内存越大，最大暂停时间就越长。想要减少最大暂停时间，就会降低吞储量。
不同的垃圾回收算法，适用于不同的场景

标记清除算法

标记清楚算法的核心思想分为两个阶段：
1.标记阶段，将所有存活的对象进行标记。Java中使用可达性分析算法，从GC Root开始通过引用链遍历出所有存活对象
2.清楚阶段，从内存中删除没有被标记也就是非存活对象。

优点：实现简单，只需要在第一阶段给每个对象维护标志位，第二个阶段删除对象即可。
缺点：1、碎片化问题
优于内存是连续的，所以在对象被删除之后，内存中会出现很多细小的可用内存单元。如果我们需要的是一个比较大的空间，很有可能这些内存单元的大小过小无法分配。

2.分配速度慢。由于内存碎片的存在，需要维护一个空闲链表，极有可能发生每次需要遍历到链表的最后才能获得合适的内存空间

复制算法

完整的复制算法的例子
1.将堆内存分割成两块From空间 To空间，对象分配阶段，创建对象。
2.GC阶段开始，将GC Root搬运到To空间
3.将GC Root关联的对象，搬运到To空间
4.清理From空间，并把名称互换

优点：
吞吐量
复制算法只需要遍历一次存活对象复制到To空间即可，比标记-整理算法少了一次遍历的过程，因而性能较好，但是不如标记-清楚算法，因为标记清除算法不需要进行对象的移动
不会发生碎片化
复制算法在复制之后就会将对象按顺序放入To空间中，所以对象以外的区域都是可用空间，不存在碎片化内存空间。
缺点
内存使用效率低
每次只能让一半的内存空间来为创建对象使用

标记整理算法

标记整理算法也叫标记压缩算法，是对标记清理算法中容易产生内存碎片问题的一种解决方案
核心思想分为两个阶段：
1.标记阶段，将所有存活的对象进行标记。Java中使用可达性分析算法，从GC Root开始通过引用链遍历出所有存活对象
2.整理阶段，将存活对象移动到堆的一端。清理掉存活对象的内存空间。

优点
内存使用效率高
整个堆内存都可以使用，不会象复制算法只能使用半个堆内存
不会发生碎片化
在整理阶段可以将对象往内存的一侧进行移动，剩下的空间都是可以分配对象的有效空间
缺点
整理阶段的效率不高
整理算法有很多种，比如Lisp2整理算法需要整个堆中的对象搜索3次，整体性能不佳。可以通过TWO-Finger、表格算法、ImmixGC等高效的整理算法优化此阶段的性能

分代垃圾回收算法

现代优秀的垃圾回收算法，会将上述描述的垃圾回收算法组合进行使用，其中应用最广的就是分代垃圾回收算法
分代垃圾回收将整个内存区域划分为年轻代和老年代：

arthas查看分代之后的内存情况

• 在JDK8中，添加-XX:+UseSerialGC参数使用分代回收的垃圾回收器，运行程序。
• 在arthas中使用memory命令查看内存，显示出三个区域的内存情况。
  
  调整内存区域的大小
  
  分代回收时，创建出来的对象，首先会被放入Eden伊甸园区。
  随着对象在Eden区越来越多，如果Eden区满了，新创建的对象已经无法放入，就会触发年轻代的GC，称为
  Minor GC或者Young GC
  Minor GC会把需要eden和From需要回收的对象回收，把没有回收的对象放入To区。
  
  接下来，S0会变成To区，S1变成From区。当eden区满时再往里放入对象，依然会发生Minor GC。
  此时会回收ede区和S1（from）中的对象，并把eden和from区中的剩余对象放入S0
  注意：每次Minor GC都会为对象记录它的年龄，初始值为0，每次GC完加1
  
  如果Minor GC对象的年龄达到阈值（最大15，默认值和垃圾回收器有关），对象就会被晋升至老年代。
  当老年代中空间不足，无法放入新的对象时，先尝试minor gc，如果还是不足，就会触发Full GC,Full GC对整个堆进行垃圾回收。
  如果Full GC依然无法回收掉老年代的对象，那么当对象继续放入老年代时，就会爬出Out Of Memory异常
  
  为什么把分代GC算法要把堆分成年轻代和老年代？
• 系统中的大部分对象，都是创建出来之后很快就不再使用可以被回收，比如用户获取订单数据，订单数据返回给用户之后就可以释放了
• 老年代中会存放长期存活的对象，比如Spring的大部分bean对象，在程序启动之后就不不会被回收了
• 在虚拟机的默认设置中，新生代大小要远小于老年代的大小。

分代GC算法将堆分成年轻代和老年代主要原因有：
1、可以通过调整年轻代和老年代的比例来适应不同类型的应用程序，提高内存的利用率和性能。
2、新生代和老年代使用不同的垃圾回收算法，新生代一般选择复制算法，老年代可以选择标记=清楚和标记-整理算法，由程序员来选择灵活度较高
3、分代的设计中允许只回收新生代（minor gc）,如果能够满足对象分配的要求就不需要堆整个堆进行回收(full-gc),STW时间就会减少。

垃圾回收器

垃圾回收器的组合关系

垃圾回收器是垃圾回收算法的具体实现。
由于垃圾回收器分为年轻代和老年代，除了G1之外其他垃圾回收器必须成对组合进行使用。
具体的关系图如下：

年轻代-Serial垃圾回收器

老年代-SerialOld垃圾回收器

年轻代-ParNew垃圾回收器

老年代-CMS(Concurrent Mark Sweep)垃圾回收器

CMS执行步骤：
1.初始标记，用极短的时间标记出GC Root能直接关联到的对象
2.并发标记，标记所有的对象，用户线程不需要暂停
3.重新标记，由于并发标记阶段有些对象会发生了变化，存在错标、漏标等情况，需要重新标记
4.并发清理，清理死亡的对象，用户线程不需要暂停。

缺点：
1、CMS使用了标记-清楚算法，在垃圾收集结束之后会出现大量的内存碎片，CMS会在Full GC时进行碎片的整理。
这样会导致用户线程暂停，可以使用-XX:CMSFullGCsBeforeCompaction=N参数（默认0）调整到N次Full GC之后再整理
2、无法处理在并发清理过程中产生的“浮动垃圾”，不能做到完全的垃圾回收
3、如果老年代内存不足无法分配对象，CMS就会退化成Serial Old单线程回收老年代

年轻代-Parallel Scavenge垃圾回收器

老年代-Parallel Old垃圾回收器

G1垃圾回收器

JDK9之后默认的垃圾回收器是G1（Garbage First）垃圾回收器
Parallel Scavenge关注吞吐量，允许用户设置最大暂停时间，但是会减少年轻代可用空间的大小。
CMS关注暂停时间，但是吞吐量方面会下降。
而G1设计目标就是将上述两种垃圾回收器的优点融合：
1.支持巨大的堆空间回收，并有较高的吞储量。
2.支持多CPU并行垃圾回收。
3.运用用户设置最大暂停时间
JDK9之后强烈建议使用G1垃圾回收器。

G1垃圾回收器-内存结构
G1出现之前的垃圾回收器，内存结构一般是连续的，如下图：

G1的整个堆会被划分成多个大小相等的区域，称之为区Region，区域不要求是连续的。分为Eden、Survivor、Old区。Region的大小通过堆空间大小/2048计算得到，也可以通过参数-XX:G1HeadRegionSize=32m指定（其中32m指定region大小为32M）,Region size必须是2的指数幂，取值范围从1M到32M。

G1垃圾回收有两种方式：

1、年轻代回收（Yount GC）
回收Eden区和Survivor区中不用的对象。会导致STW,G1中可以通过参数-XX:MaxGCPauseMillis=n(默认200)设置每次垃圾回收时的最大暂停时间毫秒数，G1垃圾回收器会尽可能地保证暂停时间。

执行流程

①新创建的对象会存放在Eden区。当G1判断年轻代不足（max默认60%），无法分配对象时会执行Young GC.
②标记出Eden和Survivor区域中的存活对象
③根据配置的最大暂停时间选择某些区域将存活对象复制到一个新的Survivor区域中（年龄+1），清空这些区域。

G1在进行Young GC的过程中会去记录每次垃圾回收时每个Eden区和Survivor区的平均耗时，以作为下次回收时的参考依据。这样就可以根据配置的最大暂停时间计算出本次回收时最多能回收多少个Region区域了。
比如：-XX:MaxGCPauseMilles=n(默认200),每个Region回收耗时40ms，那么这次回收最多只能回收4个Region.

④后续Young G时与之前相同，只不过Survivo区中存活对象会被搬运到另一个Survivor区
⑤当某个存活对象的年龄达到阈值（默认15），将被放入老年代。

⑥部分对象如果大小超过Region的一半，会直接放入老年代，这类老年代被称为Humongous区。比如堆内存是4G,每个Region是2M,只要一个大对象超过了1M就被放入Humongous区，如果对象过大会横跨多个Region.

⑦、多次回收之后，会出现很多Old老年区，此时总堆占有率达到阈值时
（-XX:InitiatingHeadpOccupancyPercent默认45%）会触发混合回收MixedGC。回收所有年轻代和部分老年代的对象以及大对象区。采用复制算法来完成。

2、混合回收（Mixed GC）

* 混合回收分为：初始标记(initial mark)、并发标记(concurrent mark)、最终标记（remark或者Finalize Marking）、并发清理(cleanup)

* G1对老年代的清理会选择存活度最低的区域来进行回收，这样可以保证回收效率最高，这也是G1(Garbage first)名称的由来

最后清理阶段使用复制算法，不会产生内存碎片

Full GC
注意：如果清理过程中发现没有足够的空Region存放转移的对象，会出现Full GC。单线程执行标记-整理算法，
此时会导致用户线程的暂停。所以尽量保证应该用的堆内存有一定多余的空间。

总结：

比较好的组合选择如下
JDK8及之前：
ParNew + CMS（关注暂停时间）、Parallel Scavenge + Parallel Old（关注吞吐量）、G1(JDK8之前不建议，较大堆并且关注暂停时间）
JDK9之后
G1(默认)
从JDK9之后，由与G1日趋成熟，JDK默认的垃圾回收器已经修改为G1，所以强烈建议在生产环境上使用G1.
1、Java有哪几块内存需要进行垃圾回收？
一般不需要回收，JSP等技术会通过回收类加载器区回收方法区中的类

2、有哪些常见的引用类型？

• 强引用，最常见的引用方式，由可达分析算法来判断
• 软引用，对象在没有强引用的情况下，内存不足时会回收
• 弱引用，对象在没有强引用的情况下，会直接回收
• 虚引用，通过虚引用知道对象被回收了
• 终结器引用，对象回收时可以自救，不建议使用
  3、有哪些场景的垃圾回收算法？
• 标记-清除算法：标记之后再清除，容易产生内存碎片
• 复制-清除算法：从一块区域复制到另一块区域容易造成只能使用一部分内存
• 标记-整理算法：标记之后将存活的对象推到一边，对象会移动，效率不高
• 分代GC：将内存区域划分成年轻代、幸存者区、老年代进行回收，可以使用多种回收算法

4、常见的垃圾回收器有哪些？

• Serial Old - Serial :单线程回收，主要适用于单核CPU场景
• CMS - ParNew：暂停时间较短，适用于大型互联网应用中与用户交互的部分
• Parallel Old - Parallel Scavenge：吞吐量高，适用于后台进行大量数据操作
• G1：使用于较大的堆，具有可控的暂停时间