jvm复制回收算法

Ⅰ JVM GC 原理 2：分代式垃圾回收算法

在 java 中，大部分对象存在时间很短，小部分对象存活时间长一些，而且存活时纤此陪间长的对象会存在很长时间。按照二八定律的说法：80%的对象占总存活时间的 20%，剩下 20%的对象存活时间却占了总存活时间的 80%

根据 java 对象的存活规律，可以将jvm 堆空间划分为新生代和老年代。新生代存放刚刚被创建的 java 对象（顾名思义嘛， 新生 代），老年代存放已经存活了一段时间的 java 对象（存活时间长了自然就进入了 老年 ）。

根据新生代 java 对象的特点：绝大部分都会在很短时间内变成垃圾，被下一次垃圾回收操作所清除。因此可以给新生代订制一款改进的 复制算法 。

将新生代所占用的堆空间进一步分为 eden 区和 survivors 区，且 s 区分为 s1 区和 s2 区。e 区空间较大，讲个 s 区空间较小，每次使用 e 区和 s 区的某一个。例如，先使用 e+s1，当没有足够空间时，将 e+s1 中的存活对象放到 s2，然后全部回收 e+s1 的空间，下一个阶段使用 e+s2，就这样依次循环。

在每次新生代垃圾回收时，记录每个对象的存活时长，当超过存活时长阈值毁蠢（可设定），则该对象将会被放到老年代中。

对于老年代，其中的 java 对象的存活特点是：存活时间长，垃圾率低。因此，在老年代垃圾回收的操作频率会极大降低，而且每次垃圾回收的数量也不多。由扒帆于这些特点，老年代一般选择使用 标记-整理算法 。

Ⅱ 以下哪些jvm的垃圾回收方式采用的是复制算法

System.gc是专门回收不用的对象的语法，当然你也可以自己写函数来finalization()你的程序。一般JVM会根据虚拟内存占用率来自动调用gc(garbage collector)，有时候即便你调用gc如果内存占用不多回收处理工作也不会调用的，毕竟调用一次也要占用资

Ⅲ JVM的垃圾算法有哪几种

一、垃圾收集器概述

如上图所示，垃圾回收算法一共有7个，3个属于年轻代、三个属于年老代，G1属于横跨年轻代和年老代的算法。

JVM会从年轻代和年老代各选出一个算法进行组合，连线表示哪些算法可以组合使用

二、各个垃圾收集器说明

1、Serial(年轻代）

• 年轻代收集器，可以和Serial Old、CMS组合使用

• 采用复制算法

• 使用单线程进行垃圾回收，回收时会导致Stop The World，用户进程停止

• client模式年轻代默认算法

• GC日志关键字：DefNew(Default New Generation)

• 图示（Serial+Serial Old)
  

  7、G1

• G1收集器由于没有使用过，所以从网上找了一些教程供大家了解

• 并行与并发

• 分代收集

• 空间整合

• 可预测的停顿

Ⅳ 你不得不知道的JVM 垃圾回收

一、四种引用方式
1.1 强引用
1.2 软引用（SoftReference）
1.3 弱引用（WeakReference）
1.4 虚引用（PhantomReference）

二、如何判断对象是垃圾
2.1 引用计数法
2.2 根可达性分析

三、垃圾回收算法
3.1 标记-清除（mark-sweep）
3.2 标记-整理（mark-compact）
3.3 标记-复制（mark-）

四、垃圾收集器
4.1 分类及特点简述
4.1.1 串行
4.1.2 吞吐量优先
4.1.3 响应时间优先
4.2 串行垃圾回收器详述
4.2.1 Serial
4.2.2 Serial-Old
4.2.3 流程图
4.3 吞吐量优先垃圾回收器详述
4.3.1 JVM相关参数
4.3.2 流程图
4.4、响应时间优先垃圾回收器详述
4.4.1 JVM相关参数
4.4.2 流程图
4.3.3 CMS的特点

五、G1垃圾回收器
5.1 相关JVM参数
5.2 特点
5.3 G1新生代垃圾回收
5.4 G1老年代垃圾回收

只有所有 GC Roots对象都不通过【强引用】引用该对象，该对象才可以被回收。

某个对象只要有一处引用关系，该对象的引用次数就加1，如果一个对象的引用次数为0，则说明该对象是垃圾。

优势：实现简单，效率较高

弊端：如果有一对对象之间形成了相互引用，但是这两个对象都已经没有被其它对象所引用了，正常情况下，这一对对象应该被作为垃圾回收掉，但是因为形成了相互引用导致无法被回收。

通过GC Root对象开始向下寻找，寻找不到的对象即说明没有被引用，那么这些没有被引用的对象被认定为垃圾。

目前，如下对象可以作为GC Root对象：

很好理解，即在GC的放生时候，先对所有对象进行根可达性分析，借此标记所有的垃圾对象；所有对象标记完毕之后会进行清理操作。

因此，总体来说，就是先标记再清除。

弊端；标记清除之后会产生大量不连续的内存碎片，碎片太多可能会导致程序运行过程中需要分配较大对象时，无法满足分配要求导致GC操作。

该回收算法操作过程基本等同于 标记-清除 算法只不过，第二步有点区别，该种方式会在清除的过程中进行 整理 操作，这是最大的不同。

优势：最终不会出现若干空间碎片而导致的空间浪费。

弊端：在整理过程中带来的计算不可小觑。

该种方式与前两种有较大的区别：

该种方式会将存储区分成两个部分，分别为From、To，其中From区域中可能存在着对象，而To区域始终为空，用做下一次接受数据做准备。

分别有两个指针指向这两个区域：From-Pointer、To-Pointer，

优点：这种算法非常适合早生夕死的对象

缺点：始终有一块内存区域是未使用的，造成空间的浪费。

特点：

特点：

特点：

JVM开关：-XX:+UseSerialGC = Serial + SerialOld

上图是：CMS垃圾回收器在老年代GC的工作流程图：

经过上面的文字分析，新生代的Region个数为所有Region个数的5%；这个数值其实是很小的，那么当新生代Region不够用的时候，JVM会划分更多的Region个数给新生代；

当新生代的Region个数占比所有Region个数超过 60% 时，就会进行一次新生代的垃圾回收。

新生代垃圾回收会造成STW。

具体的垃圾回收算法同其它几个新生代垃圾回收器一样，新生代都使用复制算法。

老年代垃圾回收触发机制与参数-XX:InitaingHeapOccupancyPercent有关。

但是需要注意的是：这一次的老年代回收，其实是一次混合垃圾回收，会同时清理新生代、老年代、Humongous。

与新生代回收算法一致，依然使用复制算法，但是垃圾回收的过程等同于老年代响应时间优先的CMS方式

流程分为：

Ⅳ JVM(二) GC算法与分代回收策略

可达性分析算法是从离散数学中的图论引入的，jvm把内存中所有的对象之间的引用关系看作一张图，通过一组名为 GC Root 的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链，瞎洞最后通过判断对象的引用链是否可达来决定对象是否可以被回收。如下图所示：

在java中，有以下几种对象可以作为GC Root：

从GC Roots集合开始，将内存整个遍历一次，保留所有可以被GC Roots直接或间接引用到的对象，而剩下的对象都当作垃圾对待并回收，过程分为两步：

如下图所示：

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

需要先从根节点开始对所有可达对象做一次标记，之后，并不是简单地清理未标记的对象，而是将所有的存活对象压缩到内存的一段。最后，清理边界外所有的空间。

JVM提供了相应的GC日志，在GC执行垃圾回收事件的时候，会有各种相应的log被打印出来，其中新生代与老年代的打印日志是有区别的。

GC Log分析相关的Java命令参数：

判断对象是否存活可以通过GC Roots的引用可达性来判断，JVM中的引用关系有四种,根据引用强度由强到弱，分别是：强引用，软引用，弱引用，虚引用

Ⅵ jvm垃圾回收有哪些算法

1.堆的分代和区域
（年轻代）Young Generation（eden、s0、s1 space） Minor GC

（老年代）Old Generation （Tenured space） Major GC|| Full GC

（永久代）Permanent Generation （Permanent space）【方法区(method area)】 Major GC

本地化的String从JDK 7开始就被移除了永久代（Permanent Generation ）

JDK 8.HotSpot JVM开始使用本地化的内存存放类的元数据，这个空间叫做元空间（Metaspace）

2.判断对象是否存活（哪些是垃圾对象）
1.引用计数（ReferenceCounting）：对象有引用计数属性，增加一个引用计数加1，减少一个引用计数减1，计数为0时可回收。（无法解决对象相互循环引用的问题）

2.根搜索（GC Roots Tracing）：GCRoot对象作为起始点（根）。如果从根到某个对象是可达的，则该对象称为“可达对象”（存活对象，不可回收对象）。否则就是不可达对象，可以被回收。

下图中，对象Object6、Object7、Object8虽然互相引用，但他们的GC Roots是不可到达的，所以它们将会被判定为是可回收的对象

3.垃圾收集算法
1.标记-清除（Mark-Sweep）算法：

标记清除算法分为“标记”和“清除”两个阶段：首先标记出需要回收的对象，标记完成之后统一清除对象。

缺点：

1、标记和清除效率不高；

2、产生大量不连续的内存碎片，导致有大量内存剩余的情况下，由于，没有连续的空间来存放较大的对象，从而触发了另一次垃圾收集动作。

2.复制（Copying）算法：
将可用内存容量划分为大小相等的两块，每次只使用其中的一块。当这一块用完之后，就将还存活的对象复制到另外一块上面，然后在把已使用过的内存空间一次清理掉。这样使得每次都是对其中的一块进行内存回收

Ⅶ JVM垃圾收集机制

JVM垃圾回收机制是java程序员必须要了解的知识，对于程序调优具有很大的帮助（同时也是大厂面试必问题）。

要了解垃圾回收机制，主要从三个方面：

（1）垃圾回收面向的对象是谁？

（2）垃圾回收算法有哪些？

（3）垃圾收集器有哪些？每个收集器有什么特点。

接下来一一讲解清楚：

一、垃圾回收面向的对象

也就是字面意思， 垃圾 回收嘛，重要的是垃圾，那什么对象是垃圾呢，简单来说就是无用的或已死的对象。这样又引申出来什么对象是已死的，怎么判断对象是否已死？

判断对象是否已死有两种算法和对象引用分类：

（1）引用计数算法：

也是字面意思，通过给对象添加引用计数器，添加引用+1，反之-1。当引用为0的时候，此时对象就可判断为无用的。

优点：实现简单，效率高。

缺点：无法解决循环引用（就是A引用B，B也引用A的情况）的问题。

（2）根搜索算法（也就是GC Roots）：

通过一系列称为GC Roots的对象，向下搜索，路径为引用链，当某个对象无法向上搜索到GC Roots，也就是成为GC Roots不可达，则为无用对象。

如果一个对象是GC Roots不可达，则需要经过两次标记才会进行回收，第一次标记的时候，会判断是否需要执行finalize方法（没必要执行的情况：没实现finalize方法或者已经执行过）。如果需要执行finalize方法，则会放入一个回收队列中，对于回收队列中的对象，如果执行finalize方法之后，没法将对象重新跟GC Roots进行关联，则会进行回收。

很抽象，对吧，来一个明了的解释？

比如手机坏了（不可达对象），有钱不在乎就直接拿去回收（这就是没实现finalize方法），如果已经修过但是修不好了（已经执行过finalize方法），就直接拿去回收站回收掉。如果没修过，就会拿去维修店（回收队列）进行维修，实在维修不好了（执行了finalize方法，但是无法连上GC Roots），就会拿去回收站回收掉了。

那什么对象可以成为GC Roots呢？

1>虚拟机栈中的引用对象

2>本地方法栈中Native方法引用的对象

2>方法区静态属性引用对象

3>方法区常量引用对象

（3）对象引用分类

1>强引用：例如实例一个对象，就是即使内存不够用了，打死都不回收的那种。

2>软引用：有用非必须对象，内存够，则不进行回收，内存不够，则回收。例如A借钱给B，当A还有钱的时候，B可以先不还，A没钱了，B就必须还了。

3>弱引用：非必须对象，只能存活到下一次垃圾回收前。

4>虚引用：幽灵引用，必须跟引用队列配合使用，目的是回收前收到系统通知。

下面是java的引用类型结构图：

（1）软引用示例

内存够用的情况：

运行结果：

内存不够用的情况：

运行结果：

（2）弱引用示例结果：

无论如何都会被回收

（3）虚引用示例：

运行结果：

解释：为什么2和5的输出为null呢，如下

3为null是因为还没有进行gc，所以对象还没加入到引用队列中，在gc后就加入到了引用队列中，所以6有值。

这个虚引用在GC后会将对象放到引用队列中，所以可以在对象回收后做相应的操作，判断对象是否在引用队列中，可以进行后置通知，类似spring aop的后置通知。

二、垃圾回收发生的区域

垃圾回收主要发生在堆内存里面，而堆内存又细分为 年轻代 和 老年代 ，默认情况下年轻代和老年代比例为1：2，比如整个堆内存大小为3G，年轻代和老年代分别就是1G和2G，想要更改这个比例需要修改JVM参数-XX:NewRatio,

比如-XX:NewRatio=4，那老年代：年轻代=4：1。而年轻代又分为Eden区，S0（Survivor From）和S1（Survivor To）区，一般Eden:S0:S1=8:1:1，如果想要更改此比例，则修改JVM参数-XX:SurvivorRatio=4，此时就是Eden:S0:S1=4:1:1。

在年轻代发生GC称为Young GC，老年代发生GC成为Full GC，Young GC比Full GC频繁。

解析Young GC：

JVM启动后，第一次GC，就会把Eden区存活的对象移入S0区；第二次GC就是Eden区和S0一起GC，此时会把存活的对象移入S1区，S0清空；第三次GC就是Eden区和S1区进行GC，会把存活的对象移入S0区，如此往复循环15次（默认），就会把存活的对象存入老年区。

类似与如果有三个桶，编号分别为1（1号桶内的沙子是源源不断的，就像工地上。你们没去工地搬过砖可能不知道，但是我真的去工地上搬过啊），2，3。1里面装有沙子，需要将沙子筛为细沙。首先将桶1内的沙子筛选一遍过后的放置于桶2，第二次筛选就会将桶1和桶2里面的沙子一起筛，筛完之后放到桶3内，桶2清空。第三次筛选就会将桶1和桶3的沙子一起筛选，晒完放到桶2内，桶3清空。如此往复循环15次，桶2或桶3里面的沙子就是合格的沙子，就需要放到备用桶内以待使用。

上述中桶1就是Eden区，桶2就是S0区，桶3就是S1区。

三、垃圾回收算法

三种，分别是复制算法，标记-清除算法，标记-整理算法。

（1）复制算法。

其会将内存区域分成同样大小的两块，一块用来使用，另外一块在GC的时候存放存活的对象，然后将使用的一块清除。如此循环往复。

适用于新生代。

优点：没有内存碎片，缺点：只能使用一般的内存。

（2）标记-清除算法。

使用所有内存区域，在GC的时候会将需要回收的内存区域先进行标记，然后同意回收。

适用于老年代。

缺点：产生大量内存碎片，会直接导致大对象无法分配内存。

（3）标记-整理算法。

使用所有内存区域，在GC的时候会先将需要回收的内存区域进行标记，然后将存活对象忘一边移动，最后将清理掉边界以外的所有内存。

适用于老年代。

四、GC日志查看

利用JVM参数-XX:+PrintGCDetails就可以在GC的时候打印出GC日志。

年轻代GC日志：

老年代GC日志：

五、垃圾收集器

主要有四类收集器以及七大收集器

四类：

（1）Serial：单线程收集器，阻塞工作线程，它一工作，全部都得停下。

（2）Paralle：Serial的多线程版本，也是阻塞工作线程

（3）CMS（ConcMarkSweep）：并行垃圾收集器，可以和工作线程一起工作。

（4）G1：将堆分成大小一致的区域，然后并发的对其进行垃圾回收。

怎么查看默认的收集器呢？

用JVM参数-XX:+PrintCommandLineFlags，运行之后会输出如下参数。可以看到，jdk1.8默认是Parallel收集器。

七大收集器：

（1）Serial：串行垃圾收集器，单线程收集器。用于新生代。用JVM参数-XX:+UseSerialGC开启，开启后Young区用Serial（底层复制算法），Old区用Serial Old（Serial的老年代版本，底层是标记整理算法）。

（2）ParNew：用于新生代，并行收集器。就是Serial的多线程版本。用JVM参数-XX:+UseParNewGC，young：parnew，复制算法。Old：serialOld，标记整理算法。-XX:ParallecGCThreads限制线程回收数量，默认跟cpu数目一样。只是新生代用并行，老年代用串行。

（3）Parallel Scavenge：并行回收收集器。用JVM参数-XX:+UseParallelGC开启，young：parallel scavenge（底层是复制算法），old：parallel old（parallel的老年代版本，底层是标记整理），新生代老年代都用并行回收器。

这个收集器有两个优点：

可控的吞吐量 ：就是工作线程工作90%的时间，回收线程工作10%的时间，即是说有90%的吞吐量。

自适应调节策略 ：会动态调节参数以获取最短的停顿时间。

（4）Parallel Old：Parallel Scavenge的老年代版本，用的是标记整理算法。用JVM参数-XX:+UseParallelOldGC开启，新生代用Parallel Scavenge，老年代用Parallel Old

（5）CMS（ConcMarkSweep）：并发标记清除。 底层是标记清除算法，所以会产生内存碎片，同时也会耗cpu。 以获取最短回收停顿时间为目标。-XX:+UseConcMarkSweep，新生代用ParNew，老年代用CMS。CMS必须在堆内存用完之前进行清除，否则会失败，这时会调用SerialOld后备收集器。

初始标记和重新标记都会停止工作线程，并发标记和并发清除会跟工作线程一起工作。

（6）SerialOld：老年代串行收集器（以后Hotspot虚拟机会直接移除掉）。

（7）G1：G1垃圾收集器，算法是标记整理，不会产生内存碎片。横跨新生代老年代。实现尽量高吞吐量，满足回收停顿时间更短。

G1可以精确控制垃圾收集的停顿时间，用JVM参数-XX:MaxGCPauseMillis=n，n为停顿时间，单位为毫秒。

区域化内存划片Region，会把整个堆划分成同样大小的区域块（1MB~32MB），最多2048个内存区域块，所以能支持的最大内存为32*2048=65535MB，约为64G。

上图是收集前和收集后的对比，有些对象很大，分割之后就是连续的区域，也即是上图的Humongous。

上述理论可能有点乏味，下图很清晰明了（某度找的）。

下面来一张整个垃圾回收机制的思维导图（太大，分成两部分）。

=======================================================

我是Liusy，一个喜欢健身的程序猿。

欢迎关注【Liusy01】，一起交流Java技术及健身，获取更多干货。

Ⅷ “JVM基础”——垃圾回收基础（GC相关）

当内存中的某一个对象无法找到任何引用的时候,这个对象就是一个垃圾对象。

内存泄露（memory leak），是指程序中已动态分配的堆内存由于某种原因程序未将其释放或无法释放，造成了内存的浪费，导致程序运行速度减慢甚至程序崩溃等严重后果。

STW即stop the world ，指的是JVM进行GC时会暂停所有业务线程。

给每一个对象添加一个引用计数器，t每当有新的引用时，计数器+1，引用结束后计数器-1。任何时刻计数器为0的对象都是不被引用的。

优点：
1. 引用计数算法在回收垃圾时具有实时性。当一个对象的引用为0的时候会被直接回收，无需等待特定时间就可以释放内存。
缺点：
1.当出现对象之间循环引用的时候，垃圾回收期无法确定这些对象是否是垃圾，因此无法回收循环引用的对象。（内存泄漏）

从GC Roots节点(起始节点)出发向下搜索，如果没有任何引用链（既GC root不可达），则证明此对象不可用

tracing GC的本质是通过找出所有活对象来把其余空间认定为“无用”，而不是找出所有死掉的对象并回收它们占用的空间。GC roots这组引用是tracing GC的起点。要实现语义正确的tracing GC，就必须要能完整枚举出所有的GC roots，否则就可能会漏扫描应该存活的对象，导致GC错误回收了这些被漏扫的活对象。

将需要清除的对象标记出来，清除掉。

标记清除算法的实现分为两个阶段：

优点：
只对存活的对象进行标记。标记完毕后再扫描整个空间中未被标记的对象进行回收。该算法不需要进行对象的移动，只需对不存活的对象进行处理，效率高。
缺点
因为直接回收掉了不存活对象，未对内存进行整理，因此会产生内存碎片。内存碎片较多时，当大对象进入内存空间，无法为期分配足够的内存会提前触发GC。

将内存一分为二，每次使用一个区域。当触发gc时，将存活对象复制到另一区域，清除原区域。

它开始时把堆分成 一个对象 面和多个空闲面， 程序从对象面为对象分配空间，当对象满了，基于ing算法的垃圾 收集就从根集合（GC Roots）中扫描活动对象，并将每个 活动对象复制到空闲面(使得活动对象所占的内存之间没有空闲洞)，这样空闲面变成了对象面，原来的对象面变成了空闲面，程序会在新的对象面中分配内存。

优点 ：

缺点：

标记清除算法的优化实现，清除垃圾对象的同时压缩空间。

该算法标记阶段和Mark-Sweep一样，但是在完成标记之后，它不是直接清理可回收对象，而是将存活对象都向一端移动，然后再清理掉无用对象

优点：
1.因为对空间进行了整理，因此不会产生内存碎片。
缺点
1.因为扫描了两次，并且在清除的基础上还增加了整理，因此时间成本高。

Ⅸ Java垃圾回收：GC在什么时候对什么做了什么

1、首先，GC又分为minor GC 和 Full GC（major GC）。Java堆内存分为新生代和老年代，新生代中又分为1个eden区和两个Survior区域。

2、一般情况下，新创建的对象都会被分配到eden区，这些对象经过一个minor gc后仍然存活将会被移动到Survior区域中，对象在Survior中没熬过一个Minor GC，年龄就会增加一岁，当他的年龄到达一定程度时，就会被移动到老年代中。

3、当eden区满时，还存活的对象将被复制到survior区，当一个survior区满时，此区域的存活对象将被复制到另外一个survior区，当另外一个也满了的时候，从前一个Survior区复制过来的并且此时还存活的对象，将可能被复制到老年代。因为年轻代中的对象基本都是尺斗乎朝生夕死（80%以上），所以年轻代的垃圾陵悉回收算法使用的是复制算法，复制算法的基本思想是将内存分为两块，每次只有其中一块，当这一块内存使用完，就将还活着的对象复制到另一块上面。复制算法销贺不会产生内存碎片。

4、在GC开始的时候，对象只会存在于eden区，和名为“From”的Survior区，Survior区“to”是空的。紧接着GCeden区中所有存活的对象都会被复制到“To”,而在from区中，仍存活的对象会根据他们的年龄值来决定去向，年龄到达一定只的对象会被复制到老年代,没有到达的对象会被复制到to survior中，经过这次gc后，eden区和fromsurvior区已经被清空。这个时候，from和to会交换他们的角色，也就是新的to就是上次GC前的fromMinor GC：从年轻代回收内存。

5、当jvm无法为一个新的对象分配空间时会触发Minor GC，比如当Eden区满了。当内存池被填满的时候，其中的内容全部会被复制，指针会从0开始跟踪空闲内存。Eden和Survior区不存在内存碎片写指针总是停留在所使用内存池的顶部。执行minor操作时不会影响到永久代，从永久带到年轻代的引用被当成GC roots，从年轻代到永久代的引用在标记阶段被直接忽略掉（永久代用来存放java的类信息）。如果eden区域中大部分对象被认为是垃圾，永远也不会复制到Survior区域或者老年代空间。如果正好相反，eden区域大部分新生对象不符合GC条件，Minor GC执行时暂停的线程时间将会长很多。Minor may call "stop the world"。

Ⅹ JVM有哪些垃圾回收算法

标记-清除，标记-复制，标记-整理