何为循环引用?
当p的指针断开的时候,内部的引用形成一个循环,这就是循环引用
![image.png](https://img-blog.csdnimg.cn/img_convert/63a410361d92d2f9f649a2838a28bcea.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=341&id=ue1d37b7e&margin=[object Object]&name=image.png&originHeight=516&originWidth=942&originalType=url&ratio=1&rotation=0&showTitle=false&size=126848&status=done&style=none&taskId=ud1efbf5b-179b-4176-96e4-25c137ae76b&title=&width=622)
代码实例:测试Java中是否采用的是引用计数算法
/**
* -XX:+PrintGCDetails
* 证明:java使用的不是引用计数算法
*/
public class RefCountGC {
//这个成员属性唯一的作用就是占用一点内存
private byte[] bigSize = new byte[5 * 1024 * 1024]; //5MB
Object reference = null;
public static void main(String[] args) {
RefCountGC obj1 = new RefCountGC();
RefCountGC obj2 = new RefCountGC();
obj1.reference = obj2;
obj2.reference = obj1;
obj1 = null;
obj2 = null;
//显式的执行垃圾回收行为
//这里发生GC,obj1和obj2能否被回收?
System.gc();
}
}
程序运行结果
![image.png](https://img-blog.csdnimg.cn/img_convert/f7d74f70cff6d80448bfe79b4af8ceed.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=171&id=ue78b53a3&margin=[object Object]&name=image.png&originHeight=257&originWidth=709&originalType=binary&ratio=1&rotation=0&showTitle=false&size=46906&status=done&style=none&taskId=u7029afb6-920a-4d90-9df9-de35b156b57&title=&width=472.6666666666667)
我们能够看到,上述进行了 GC 收集的行为,将上述的新生代中的两个对象都进行回收了。
![image.png](https://img-blog.csdnimg.cn/img_convert/2bbd3eedeff13737d9da24c6d1dcd24a.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=28&id=u193e46f7&margin=[object Object]&name=image.png&originHeight=42&originWidth=706&originalType=binary&ratio=1&rotation=0&showTitle=false&size=6511&status=done&style=none&taskId=uf7039915-20b6-4006-81fc-45dee6a6ff3&title=&width=470.6666666666667)
如果使用引用计数算法,那么这两个对象将会无法回收。而现在两个对象被回收了,说明 JVM中采用的一定不是 引用计数算法 来进行标记的。
![image.png](https://img-blog.csdnimg.cn/img_convert/e764ac64a66a39f891e31c94fa95c160.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=293&id=uf1f71d62&margin=[object Object]&name=image.png&originHeight=512&originWidth=1057&originalType=url&ratio=1&rotation=0&showTitle=false&size=250520&status=done&style=none&taskId=u13f09965-5845-4ac2-9fbc-a0cde847e16&title=&width=605)
![image.png](https://img-blog.csdnimg.cn/img_convert/3eb2451bc5997dc49594606fcdcc87c8.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=352&id=ub71793fc&margin=[object Object]&name=image.png&originHeight=502&originWidth=920&originalType=url&ratio=1&rotation=0&showTitle=false&size=145225&status=done&style=none&taskId=uf3b91f76-dd36-432f-9479-f4af243ee08&title=&width=645)
这里需要注意的是,可达性分析算法中,每次标记的是直接或间接与 GC Roots 连接的对象,标记完成后,遍历整个内存空间,将没有被标记的对象删除。
在Java语言中,GC Roots包括以下几类元素:
小技巧:
由于Root采用栈方式存放变量和指针,所以如果一个指针,它保存了堆内存里面的对象,但是自己又不存放在堆内存里面,那它就是一个Root。
红色的都没有被GC Roots所引用,所以都是垃圾
![image.png](https://img-blog.csdnimg.cn/img_convert/f39fb6404eac0a51b49d1a214c127564.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=399&id=u4d3faecf&margin=[object Object]&name=image.png&originHeight=539&originWidth=756&originalType=url&ratio=1&rotation=0&showTitle=false&size=350486&status=done&style=none&taskId=u76d0f994-e732-4cbb-9583-f5589f44a1c&title=&width=559)
注意:
判定一个对象 objA 是否可回收,至少要经历两次标记过程:
![image.png](https://img-blog.csdnimg.cn/img_convert/8f40b60e3626ea67530dc66551e0cd5a.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=ufc9f7e14&margin=[object Object]&name=image.png&originHeight=1376&originWidth=2386&originalType=url&ratio=1&rotation=0&showTitle=false&size=312495&status=done&style=none&taskId=ufb4871a7-3041-4cee-af77-381c7818df8&title=)
上图就是我们看到的 Finalizer 线程。
我们重写 finalize() 方法,然后在方法的内部,重写将其存放到 GC Roots 中。
/**
* 测试Object类中finalize()方法,即对象的finalization机制。
*/
public class CanReliveObj {
public static CanReliveObj obj; //类变量,属于 GC Root
//此方法只能被调用一次
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("调用当前类重写的finalize()方法");
obj = this;//当前待回收的对象在finalize()方法中与引用链上的一个对象obj建立了联系
}
public static void main(String[] args) {
try {
obj = new CanReliveObj();
// 对象第一次成功拯救自己
obj = null;
System.gc();//调用垃圾回收器
System.out.println("-----------------第一次gc操作------------");
// 因为Finalizer线程优先级很低,暂停2秒,以等待它
Thread.sleep(2000);
if (obj == null) {
System.out.println("obj is dead");
} else {
System.out.println("obj is still alive");
}
System.out.println("-----------------第二次gc操作------------");
// 下面这段代码与上面的完全相同,但是这次自救却失败了
obj = null;
System.gc();
// 因为Finalizer线程优先级很低,暂停2秒,以等待它
Thread.sleep(2000);
if (obj == null) {
System.out.println("obj is dead");
} else {
System.out.println("obj is still alive");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
程序运行结果
![image.png](https://img-blog.csdnimg.cn/img_convert/09b01024603a37b01b7fd94d35450e02.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=83&id=u4a13b5fc&margin=[object Object]&name=image.png&originHeight=124&originWidth=578&originalType=binary&ratio=1&rotation=0&showTitle=false&size=6238&status=done&style=none&taskId=ub71f6da7-b672-4cc7-ad16-37dcc70d0ea&title=&width=385.3333333333333)
在进行第一次清除的时候,我们会执行 finalize() 方法,然后对象进行了一次自救操作,但是因为 finalize() 方法只会被调用一次,因此第二次该对象将会被垃圾清除。
![image.png](https://img-blog.csdnimg.cn/img_convert/a7619bc147fa1aa3c7ea22258f6b4411.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=187&id=u8cc45b52&margin=[object Object]&name=image.png&originHeight=448&originWidth=1153&originalType=url&ratio=1&rotation=0&showTitle=false&size=247287&status=done&style=none&taskId=u611bb1da-9d90-426e-8654-0a3b5b8f62d&title=&width=481)
public class GCRootsTest {
public static void main(String[] args) {
List<Object> numList = new ArrayList<>();
Date birth = new Date();
for (int i = 0; i < 100; i++) {
numList.add(String.valueOf(i));
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("数据添加完毕,请操作:");
new Scanner(System.in).next();
numList = null;
birth = null;
System.out.println("numList、birth已置空,请操作:");
new Scanner(System.in).next();
System.out.println("结束");
}
}
启动VisualVM,点击Heap Dump
![image.png](https://img-blog.csdnimg.cn/img_convert/d96c6461f3832e23ca3e67f9c39382ae.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=347&id=u4251612d&margin=[object Object]&name=image.png&originHeight=1376&originWidth=2386&originalType=url&ratio=1&rotation=0&showTitle=false&size=298688&status=done&style=none&taskId=uafe0b3ed-8282-4a0b-a55b-9dc50be7877&title=&width=602)
dump出两个文件,把它另存到桌面
![image.png](https://img-blog.csdnimg.cn/img_convert/b56cdce380090c6835b4364e49ddd854.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=358&id=u12c3557c&margin=[object Object]&name=image.png&originHeight=1376&originWidth=2386&originalType=url&ratio=1&rotation=0&showTitle=false&size=414281&status=done&style=none&taskId=ua01a2cab-be06-4688-a584-ae075a3a4dc&title=&width=621)
![image.png](https://img-blog.csdnimg.cn/img_convert/bd593d5f320a25374bff3069ecfe2a4d.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=202&id=ub8007d00&margin=[object Object]&name=image.png&originHeight=446&originWidth=1350&originalType=url&ratio=1&rotation=0&showTitle=false&size=329319&status=done&style=none&taskId=u227e0123-1f0e-49f7-95cf-805d710c09a&title=&width=612)
我们在实际的开发中,一般不会查找全部的 GC Roots,可能只是查找某个对象的整个链路,或者称为 GC Roots 溯源,这个时候,我们就可以使用 JProfiler。
public class GCRootsTest {
public static void main(String[] args) {
List<Object> numList = new ArrayList<>();
Date birth = new Date();
for (int i = 0; i < 100; i++) {
numList.add(String.valueOf(i));
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("数据添加完毕,请操作:");
new Scanner(System.in).next();
numList = null;
birth = null;
System.out.println("numList、birth已置空,请操作:");
new Scanner(System.in).next();
System.out.println("结束");
}
}
运行程序,打开JProfiler
![image.png](https://img-blog.csdnimg.cn/img_convert/f603e44a43843c860aa57f543510107a.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=497&id=u90bf55fb&margin=[object Object]&name=image.png&originHeight=1800&originWidth=2400&originalType=url&ratio=1&rotation=0&showTitle=false&size=369036&status=done&style=none&taskId=u4ec17d64-e45a-4c40-963f-e0a17216ed5&title=&width=662)
![image.png](https://img-blog.csdnimg.cn/img_convert/478ccde16f01bba73bfd9fa203f8dd16.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=500&id=u9557448f&margin=[object Object]&name=image.png&originHeight=1870&originWidth=2422&originalType=url&ratio=1&rotation=0&showTitle=false&size=815410&status=done&style=none&taskId=ue81afaad-6c10-4ac2-b7ad-af0efa42571&title=&width=647)
![image.png](https://img-blog.csdnimg.cn/img_convert/24cb9d990107daa381b5c6e929e4ed5a.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=482&id=uc01e2432&margin=[object Object]&name=image.png&originHeight=1800&originWidth=2400&originalType=url&ratio=1&rotation=0&showTitle=false&size=665999&status=done&style=none&taskId=u854ef0af-5783-4ec4-9a15-dd12f619a3f&title=&width=643)
![image.png](https://img-blog.csdnimg.cn/img_convert/c42a5da58bfa1bf72b6d2d6fa3f13d48.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=484&id=u1ea178f5&margin=[object Object]&name=image.png&originHeight=1800&originWidth=2400&originalType=url&ratio=1&rotation=0&showTitle=false&size=768136&status=done&style=none&taskId=ua4c2222d-d184-4329-82ae-3976f320731&title=&width=645)
![](https://img-blog.csdnimg.cn/img_convert/f2c459e089f12fb1530e88a00f15cdab.png#clientId=u0441b218-ed9e-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=u01ef3072&margin=[object Object]&originHeight=866&originWidth=1677&originalType=url&ratio=1&rotation=0&showTitle=false&status=done&style=none&taskId=u7fcf03fd-3751-4fe4-9857-224b1930c24&title=)
/**
* 内存溢出排查
* -Xms8m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError
*/
public class HeapOOM {
byte[] buffer = new byte[1 * 1024 * 1024];//1MB
public static void main(String[] args) {
ArrayList<HeapOOM> list = new ArrayList<>();
int count = 0;
try {
while (true) {
list.add(new HeapOOM());
count++;
}
} catch (Throwable e) {
System.out.println("count = " + count);
e.printStackTrace();
}
}
}
设置JVM参数 -Xms8m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError
-XX:+HeapDumpOnOutOfMemoryError
将出错时候的 dump 文件输出。![image.png](https://img-blog.csdnimg.cn/img_convert/aaae1eab45d099443da43c7ec9cd0ead.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=181&id=u5426362b&margin=[object Object]&name=image.png&originHeight=594&originWidth=1782&originalType=url&ratio=1&rotation=0&showTitle=false&size=145356&status=done&style=none&taskId=ufa0c5392-3fc3-4998-88bd-c32909e3822&title=&width=542)
![image.png](https://img-blog.csdnimg.cn/img_convert/b7a0e76d57644e6b6aaf4f681958f9ad.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=338&id=ubbf68a4e&margin=[object Object]&name=image.png&originHeight=1054&originWidth=1686&originalType=url&ratio=1&rotation=0&showTitle=false&size=452139&status=done&style=none&taskId=u77224f16-8396-4bf8-b258-21c09a30f5f&title=&width=541)
我们将生成的 dump 文件打开,然后点击 Biggest Objects 就能够看到超大对象。
![image.png](https://img-blog.csdnimg.cn/img_convert/ca5805d2c654cc6f4ddf55641a3ce130.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=u8f29bdb5&margin=[object Object]&name=image.png&originHeight=1800&originWidth=2400&originalType=url&ratio=1&rotation=0&showTitle=false&size=607838&status=done&style=none&taskId=uab08f9eb-3dbf-45ec-bb31-62cb15f1045&title=)
然后我们通过线程,还能够定位到哪里出现 OOM。
![image.png](https://img-blog.csdnimg.cn/img_convert/d4da60e1b3084aae64421aa963ecdbfb.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=uc9da3e70&margin=[object Object]&name=image.png&originHeight=1800&originWidth=2400&originalType=url&ratio=1&rotation=0&showTitle=false&size=295219&status=done&style=none&taskId=u4fa67bec-c069-41df-adf2-fa4494eefb3&title=)
![image.png](https://img-blog.csdnimg.cn/img_convert/d134fbd6c1c05d088c1f9802b245b9ff.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=300&id=u79f4a747&margin=[object Object]&name=image.png&originHeight=1402&originWidth=2116&originalType=url&ratio=1&rotation=0&showTitle=false&size=254886&status=done&style=none&taskId=u131c459b-7859-481c-b937-65056931572&title=&width=453)
当成功区分出内存中存活对象和死亡对象后,GC 接下来的任务就是执行垃圾回收,释放掉无用对象所占用的内存空间,以便有足够的可用内存空间为新对象分配内存。目前在 JVM 中比较常见的三种垃圾收集算法是:
标记-清除算法(Mark-Sweep)是一种非常基础和常见的垃圾收集算法,该算法被 J.McCarthy 等人在 1960 年提出并并应用于 Lisp 语言。
当堆中的有效内存空间(Available Memory)被耗尽的时候,就会停止整个程序(也被称为 Stop The World),然后进行两项工作,第一项则是标记,第二项则是清除。
![image.png](https://img-blog.csdnimg.cn/img_convert/af952ea79e75e4e4d02f19e60b7618a4.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=426&id=u00228d28&margin=[object Object]&name=image.png&originHeight=1262&originWidth=1625&originalType=url&ratio=1&rotation=0&showTitle=false&size=212373&status=done&style=none&taskId=u49bac747-35e8-4cbc-ac50-3fc752e4f59&title=&width=549)
为了解决标记-清除算法在垃圾收集效率方面的缺陷,M.L.Minsky 于 1963 年发表了著名的论文,“使用双存储区的 Lisp 语言垃圾收集器 CA LISP Garbage Collector Algorithm Using Serial Secondary Storage)”。M.L.Minsky 在该论文中描述的算法被人们称为复制(Copying)算法,它也被 M.L.Minsky 本人成功地引入到了Lisp 语言的一个实现版本中。
将活着的内存空间分为两块,每次只使用其中一块,在垃圾回收时将正在使用的内存中的存活对象复制到未被使用的内存块中,之后清除正在使用的内存块中的所有对象,交换两个内存的角色,最后完成垃圾回收
![image.png](https://img-blog.csdnimg.cn/img_convert/89a45bef671df6621ae25b7efa60226b.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=306&id=u8f6bc39a&margin=[object Object]&name=image.png&originHeight=1008&originWidth=1793&originalType=url&ratio=1&rotation=0&showTitle=false&size=217830&status=done&style=none&taskId=u4a0010ca-22df-4755-8bf4-29e2a6c7263&title=&width=544)
优点
缺点
在新生代,对常规应用的垃圾回收,一次通常可以回收 70% - 99% 的内存空间。回收性价比很高。所以现在的商业虚拟机都是用这种收集算法回收新生代。
![image.png](https://img-blog.csdnimg.cn/img_convert/18da9da7673868fde09373186092a262.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=231&id=u49a54fc6&margin=[object Object]&name=image.png&originHeight=415&originWidth=799&originalType=url&ratio=1&rotation=0&showTitle=false&size=122889&status=done&style=none&taskId=u7f149c1b-82ed-4552-b1b2-9d99955dd25&title=&width=445)
![image.png](https://img-blog.csdnimg.cn/img_convert/bfe951958d8e346e21214e3f08ec3b01.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=438&id=u005ce323&margin=[object Object]&name=image.png&originHeight=1269&originWidth=1637&originalType=url&ratio=1&rotation=0&showTitle=false&size=262536&status=done&style=none&taskId=u4503e857-2d71-40d7-8922-210fe4b5236&title=&width=565)
指针碰撞
如果内存空间以规整和有序的方式分布,即已用和未用的内存都各自一边,彼此之间维系着一个记录下一次分配起始点的标记指针,当为新对象分配内存时,只需要通过修改指针的偏移量将新对象分配在第一个空闲内存位置上,这种分配方式就叫做指针碰撞(Bump the Pointer)
优点
缺点
标记清除 (Mark-Sweep) | 标记整理 (Mark-Compact) | 复制 (Copying) | |
---|---|---|---|
速率 | 中等 | 最慢 | 最快 |
空间开销 | 少(但会堆积碎片) | 少(不堆积碎片) | 通常需要活对象的2倍空间(不堆积碎片) |
移动对象 | 否 | 是 | 是 |
目前几乎所有的 GC 都采用分代收集算法执行垃圾回收的。
在 HotSpot 中,基于分代的概念,GC 所使用的内存回收算法必须结合年轻代和老年代各自的特点。
年轻代特点:区域相对老年代较小,对象生命周期短、存活率低,回收频繁。
这种情况复制算法的回收整理,速度是最快的。复制算法的效率只和当前存活对象大小有关,因此很适用于年轻代的回收。而复制算法内存利用率不高的问题,通过 HotSpot 中的两个 Survivor 的设计得到缓解。
老年代特点:区域较大,对象生命周期长、存活率高,回收不及年轻代频繁。
这种情况存在大量存活率高的对象,复制算法明显变得不合适。一般是由标记-清除或者是标记-清除与标记-整理的混合实现。
以 HotSpot 中的 CMS 回收器为例,CMS 是基于 Mark-Sweep 实现的,对于对象的回收效率很高。而对于碎片问题,CMS 采用基于 Mark-Compact 算法的 Serial Old 回收器作为补偿措施:当内存回收不佳(碎片导致的 Concurrent Mode Failure 时),将采用 Serial Old 执行 Full GC 以达到对老年代内存的整理。
分代的思想被现有的虚拟机广泛使用,几乎所有的垃圾回收器都区分新生代和老年代。
上述现有的算法,在垃圾回收过程中,应用软件将处于一种 Stop the World 的状态。在 Stop the World 状态下,应用程序所有的线程都会挂起,暂停一切正常的工作,等待垃圾回收的完成。如果垃圾回收时间过长,应用程序会被挂起很久,将严重影响用户体验或者系统的稳定性。为了解决这个问题,即对实时垃圾收集算法的研究直接导致了增量收集(Incremental Collecting)算法的诞生。
使用这种方式,由于在垃圾回收过程中,间断性地还执行了应用程序代码,所以能减少系统的停顿时间。但是,因为线程切换和上下文转换的消耗,会使得垃圾回收的总体成本上升,造成系统吞吐量的下降。
![image.png](https://img-blog.csdnimg.cn/img_convert/f8e4bab2d5a3b50a58bc1bba41e55234.png#clientId=u4d9d3e34-44b7-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=200&id=uc6efa8ed&margin=[object Object]&name=image.png&originHeight=517&originWidth=781&originalType=url&ratio=1&rotation=0&showTitle=false&size=394484&status=done&style=none&taskId=ue13a0487-0136-455c-8a37-9f1bc951871&title=&width=302)
注意,这些只是基本的算法思路,实际 GC 实现过程要复杂得多,目前还在发展中的前沿 GC 都是复合算法,并且并行和并发兼备。