使用sun.misc.Cleaner或者PhantomReference实现堆外内存的自动释放

r囧r小猫 2021-09-14 18:54 224阅读 0赞

[http://blog.csdn.net/aitangyong/article/details/39455229][http_blog.csdn.net_aitangyong_article_details_39455229]

我之前的一篇博客：[System.gc()和-XX:+DisableExplicitGC启动参数，以及DirectByteBuffer的内存释放][System.gc_-XX_DisableExplicitGC_DirectByteBuffer] 文章末尾处：提到java NIO包是通过sun.misc.Cleaner和PhantomReference来实现堆外内存的自动释放的。现在我们来学习下Cleaner和PhantomReference的使用，自己封装实现堆外内存的自动释放。

sun.misc.Cleaner是JDK内部提供的用来释放非堆内存资源的API。JVM只会帮我们自动释放堆内存资源，但是它提供了回调机制，通过这个类能方便的释放系统的其他资源。我们先看下如何使用Cleaner。

\[java\]  [view plain][]  [copy][view plain]

1.  package direct;  
2.  public class FreeMemoryTask implements Runnable  
3.  \{  
4.      private long address = 0;  
5.    
6.      public FreeMemoryTask(long address)  
7.      \{  
8.          this.address = address;  
9.      \}  
10.   
11.     @Override  
12.     public void run()  
13.     \{  
14.         System.out.println("runing FreeMemoryTask");  
15.   
16.         if (address == 0)  
17.         \{  
18.             System.out.println("already released");  
19.         \} else  
20.         \{  
21.             GetUsafeInstance.getUnsafeInstance().freeMemory(address);  
22.         \}  
23.   
24.     \}  
25. \}

这个实现了Runnable接口的类，功能就是释放堆外内存。这是我们必须要做的事，JVM没有办法帮我们做。

\[java\]  [view plain][]  [copy][view plain]

1.  public class ObjectInHeapUseCleaner  
2.  \{  
3.      private long address = 0;  
4.    
5.      public ObjectInHeapUseCleaner()  
6.      \{  
7.          address = GetUsafeInstance.getUnsafeInstance().allocateMemory(  
8.                  2 \* 1024 \* 1024);  
9.      \}  
10.   
11.     public static void main(String\[\] args)  
12.     \{  
13.         while (true)  
14.         \{  
15.             System.gc();  
16.   
17.             ObjectInHeapUseCleaner heap = new ObjectInHeapUseCleaner();  
18.   
19.             // 增加heap的虚引用,定义清理的接口FreeMemoryTask  
20.             Cleaner.create(heap, new FreeMemoryTask(heap.address));  
21.         \}  
22.     \}  
23. \}

运行这段代码，可以发现程序正常运行，不会出现OOM。

Cleaner.create()需要2个参数：第一个参数：需要监控的堆内存对象，第二个参数：程序释放资源的回调。当JVM进行GC的时候，如果发现我们监控的对象，不存在强引用了（只被Cleaner对象引用，这是个幽灵引用），就会调用第二个参数Runnable.run()方法的逻辑，执行完Runnable.run()的时候（这个时候已经释放了堆外内存），JVM会自动释放堆内存中我们监控的对象。可以看到使用sun.misc.Cleaner很简单。

接下来我们看下，不使用sun.misc.Cleaner的情况下，如何释放资源。

\[java\]  [view plain][]  [copy][view plain]

1.  import java.lang.ref.PhantomReference;  
2.  import java.lang.ref.Reference;  
3.  import java.lang.ref.ReferenceQueue;  
4.  import java.util.HashMap;  
5.  import java.util.Map;  
6.    
7.  public class MyOwnCleaner  
8.  \{  
9.    
10.     private static ReferenceQueue<Object> refQueue = new ReferenceQueue<Object>();  
11.   
12.     private static Map<Reference<Object>, Runnable> taskMap = new HashMap<Reference<Object>, Runnable>();  
13.   
14.     static  
15.     \{  
16.         new CleanerThread().start();  
17.     \}  
18.   
19.     public static void clear(Object heapObject, Runnable task)  
20.     \{  
21.         // 当heapObject没有强引用的时候,reference会自动被JVM加入到引用队列中  
22.         // 不管使用有人持有reference对象的强引用  
23.         PhantomReference<Object> reference = new PhantomReference<Object>(  
24.                 heapObject, refQueue);  
25.   
26.         taskMap.put(reference, task);  
27.   
28.     \}  
29.   
30.     // 清理线程  
31.     private static class CleanerThread extends Thread  
32.     \{  
33.         @Override  
34.         public void run()  
35.         \{  
36.             while (true)  
37.             \{  
38.                 try  
39.                 \{  
40.                     @SuppressWarnings("unchecked")  
41.                     Reference<Object> refer = (Reference<Object>) refQueue  
42.                             .remove();  
43.   
44.                     Runnable r = taskMap.remove(refer);  
45.                     r.run();  
46.                 \} catch (InterruptedException e)  
47.                 \{  
48.   
49.                 \}  
50.   
51.             \}  
52.         \}  
53.     \}  
54.   
55. \}

这里使用到了PhantomReference和ReferenceQueue，这是JVM内部的对象销毁机制。当堆中的对象不存在强引用，只存在幽灵引用的时候，JVM会自动将这个对象的幽灵引用加入到与之相关联的的引用队列中。

\[java\]  [view plain][]  [copy][view plain]

1.  private static ReferenceQueue<Object> refQueue = new ReferenceQueue<Object>();

这个就是引用队列，JVM会自动将幽灵引用PhantomReference加入到队列中。也就是说，我们只要轮询这个队列，就能够知道哪些对象即将被JVM回收（这些对象只存在幽灵引用了）。

\[java\]  [view plain][]  [copy][view plain]

1.  public static void clear(Object heapObject, Runnable task)  
2.  \{  
3.      // 当heapObject没有强引用的时候,reference会自动被JVM加入到引用队列中  
4.      // 不管使用有人持有reference对象的强引用  
5.      PhantomReference<Object> reference = new PhantomReference<Object>(  
6.              heapObject, refQueue);  
7.      taskMap.put(reference, task);  
8.  \}

这段代码，相当于是我们给堆中的对象heapObject添加了一个监控（注册了一个幽灵引用）。taskMap记录幽灵引用和相应的代码回收逻辑。 之后我们在后台开启了一个CleanerThread线程，不断的轮询引用队列，一旦发现队列中有数据(PhantomReference对象)， 就找出对应的Runnable，调用它的run方法，释放堆对象heapObject中引用的堆外内存。测试代码如下：

\[java\]  [view plain][]  [copy][view plain]

1.  public class Test  
2.  \{  
3.      private long address = 0;  
4.    
5.      public Test()  
6.      \{  
7.          address = GetUsafeInstance.getUnsafeInstance().allocateMemory(  
8.                  2 \* 1024 \* 1024);  
9.      \}  
10.   
11.     public static void main(String\[\] args)  
12.     \{  
13.         while (true)  
14.         \{  
15.             Test heap = new Test();  
16.   
17.             MyOwnCleaner.clear(heap, new FreeMemoryTask(heap.address));  
18.   
19.             System.gc();  
20.         \}  
21.     \}  
22. \}

运行测试代码，可以发现也不会报OOM，即正确地实现了堆外内存的自动释放。

[http_blog.csdn.net_aitangyong_article_details_39455229]: http://blog.csdn.net/aitangyong/article/details/39455229
[System.gc_-XX_DisableExplicitGC_DirectByteBuffer]: http://blog.csdn.net/aitangyong/article/details/39403031
[view plain]: http://blog.csdn.net/aitangyong/article/details/39455229#

发表评论取消回复

表情：

评论列表（有 0 条评论，224人围观）

还没有评论，来说两句吧...

相关阅读

相关简单谈谈堆外内存

简单谈谈堆外内存以及你的理解和认识 JVM源码分析之堆外内存完全解读概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们

柔光的暖阳◎/ 2024年03月22日 16:17/ 0 赞/ 65 阅读

相关 JVM如何分配和回收堆外内存

在JVM中内存被分成两大块，分别是堆内存和堆外内存，堆内存就是JVM使用的内存，而堆外内存就是非JVM使用的内存，一般是分配给机器使用的内存。那么整个内存模型如下： !

比眉伴天荒/ 2023年10月01日 22:29/ 0 赞/ 29 阅读

相关 linux释放内存

Linux释放内存的命令： sync echo 1 > /proc/sys/vm/drop_caches drop\_caches的值可以是0-3之间的数字

不念不忘少年蓝@/ 2023年01月01日 03:42/ 0 赞/ 273 阅读

相关堆外内存的回收机制分析

目录堆外内存堆外内存的申请和释放堆外内存的回收机制 -------------------- 堆外内存 JVM启动时分配的内存，称为堆内存，与之相对的，在

以你之姓@/ 2022年10月31日 00:50/ 0 赞/ 246 阅读

相关 Centos7 释放内存

// 查看内存使用情况 [root@localhost ~] free -m // 释放cache [root@localhost ~] syn

快来打我*/ 2022年10月02日 07:43/ 0 赞/ 278 阅读

相关 vector使用swap释放内存

使用vector的时候一般会先调用reserve扩充一个比较大的容量，以免vector在push\_back超过capacity时自动扩容造成的低效率的拷贝操作。当我们插入

朴灿烈づ我的快乐病毒、/ 2022年07月12日 11:46/ 0 赞/ 326 阅读

相关手动释放ubuntu内存

当在Linux下频繁存取文件后，物理内存会很快被用光，当程序结束后，内存不会被正常释放，而是一直作为caching。这个问题，貌似有不少人在问，不过都没有看到有什么很好解决的办

刺骨的言语ヽ痛彻心扉/ 2022年06月18日 03:50/ 0 赞/ 305 阅读

相关 NIO详解（六）：Java堆外内存

1. 前言最近研究ByteBuffer和DirectByteBuffer。堆外内存是相对于堆内内存的一个概念。堆内内存是由JVM所管控的Java进程内存，我们平时在Ja

朴灿烈づ我的快乐病毒、/ 2022年03月02日 16:30/ 0 赞/ 1147 阅读

相关 Linux系统释放内存

在Linux系统下，我们一般不需要去释放内存，因为系统已经将内存管理的很好。但是凡事也有例外，有的时候内存会被缓存占用掉，导致系统使用SWAP空间，非常影响性能。例

谁借莪１个温暖的怀抱￠/ 2021年09月20日 15:08/ 0 赞/ 430 阅读

相关使用sun.misc.Cleaner或者PhantomReference实现堆外内存的自动释放

[http://blog.csdn.net/aitangyong/article/details/39455229][http_blog.csdn.net_aitangyong

r囧r小猫/ 2021年09月14日 18:54/ 0 赞/ 225 阅读