Netty内存泄露检测原理分析

引用计数
netty中使用引用计数机制来管理资源,当一个实现ReferenceCounted的对象实例化时,引用计数置1.
客户代码中需要保持一个该对象的引用时需要调用接口的retain方法将计数增1.对象使用完毕时调用release将计数减1.
当引用计数变为0时,对象将释放所持有的底层资源或将资源返回资源池.

内存泄露
按上述规则使用Direct和Pooled的ByteBuf尤其重要.对于DirectBuf,其内存不受VM垃圾回收控制只有在调用release导致计数为0时才会主动释放内存,而PooledByteBuf只有在release后才能被回收到池中以循环利用.
如果客户代码没有按引用计数规则使用这两种对象,将会导致内存泄露.

内存使用跟踪
在netty.io.util包中含有如下两个类
ResourceLeak 用于跟踪内存泄露
ResourceLeakDetector 内存泄露检测工具

在io.netty.buffer.AbstractByteBufAllocator类中有如下代码

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. //装饰器模式,用SimpleLeakAwareByteBuf或AdvancedLeakAwareByteBuf来包装原始的ByteBuf  
  2. //两个包装类均通过调用ResourceLeak的record方法来记录ByteBuf的方法调用堆栈,区别在于后者比前者记录更多的内容  
  3. protected static ByteBuf toLeakAwareBuffer(ByteBuf buf) {  
  4.     ResourceLeak leak;  
  5.     //根据设置的Level来选择使用何种包装器  
  6.     switch (ResourceLeakDetector.getLevel()) {  
  7.         case SIMPLE:  
  8.             //创建用于跟踪和表示内容泄露的ResourcLeak对象  
  9.             leak = AbstractByteBuf.leakDetector.open(buf);  
  10.             if (leak != null) {  
  11.                 //只在ByteBuf.order方法中调用ResourceLeak.record  
  12.                 buf = new SimpleLeakAwareByteBuf(buf, leak);  
  13.             }  
  14.             break;  
  15.         case ADVANCED:  
  16.         case PARANOID:  
  17.             leak = AbstractByteBuf.leakDetector.open(buf);  
  18.             if (leak != null) {  
  19.                 //在ByteBuf几乎所有方法中调用ResourceLeak.record    
  20.                 buf = new AdvancedLeakAwareByteBuf(buf, leak);  
  21.             }  
  22.             break;  
  23.     }  
  24.     return buf;  
  25. }  

下图展示了该方法被调用的时机.可见Netty只对PooledByteBuf和DirectByteBuf监控内存泄露.




内存泄露检测

下面观察上述代码中的AbstractByteBuf.leakDetector.open(buf);

实现代码如下
[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. //创建用于跟踪和表示内容泄露的ResourcLeak对象  
  2. public ResourceLeak open(T obj) {  
  3.     Level level = ResourceLeakDetector.level;  
  4.     if (level == Level.DISABLED) {//禁用内存跟踪  
  5.         return null;  
  6.     }  
  7.     if (level.ordinal() < Level.PARANOID.ordinal()) {  
  8.         //如果监控级别低于PARANOID,在一定的采样频率下报告内存泄露  
  9.         if (leakCheckCnt ++ % samplingInterval == 0) {  
  10.             reportLeak(level);  
  11.             return new DefaultResourceLeak(obj);  
  12.         } else {  
  13.             return null;  
  14.         }  
  15.     } else {  
  16.         //每次需要分配 ByteBuf 时,报告内存泄露情况  
  17.         reportLeak(level);  
  18.         return new DefaultResourceLeak(obj);  
  19.     }  
  20. }  

其中reportLeak方法中完成对内存泄露的检测和报告,如下面代码所示.

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. private void reportLeak(Level level) {  
  2.     //......  
  3.   
  4.     // 报告生成了太多的活跃资源  
  5.     int samplingInterval = level == Level.PARANOID? 1 : this.samplingInterval;  
  6.     if (active * samplingInterval > maxActive && loggedTooManyActive.compareAndSet(falsetrue)) {  
  7.         logger.error("LEAK: You are creating too many " + resourceType + " instances.  " +  
  8.                 resourceType + " is a shared resource that must be reused across the JVM," +  
  9.                 "so that only a few instances are created.");  
  10.     }  
  11.   
  12.     // 检测并报告之前发生的内存泄露  
  13.     for (;;) {  
  14.         @SuppressWarnings("unchecked")  
  15.         //检查引用队列(为什么通过检查该队列,可以判断是否存在内存泄露)  
  16.         DefaultResourceLeak ref = (DefaultResourceLeak) refQueue.poll();  
  17.         if (ref == null) {//队列为空,没有未报告的内存泄露或者从未发生内存泄露  
  18.             break;  
  19.         }  
  20. <span style="white-space:pre">    </span>//清理引用  
  21.         ref.clear();  
  22.   
  23.         if (!ref.close()) {  
  24.             continue;  
  25.         }  
  26.         //通过错误日志打印资源的方法调用记录,并将其保存在reportedLeaks中  
  27.         String records = ref.toString();  
  28.         if (reportedLeaks.putIfAbsent(records, Boolean.TRUE) == null) {  
  29.             if (records.isEmpty()) {  
  30.                 logger.error("LEAK: {}.release() was not called before it's garbage-collected. " +  
  31.                         "Enable advanced leak reporting to find out where the leak occurred. " +  
  32.                         "To enable advanced leak reporting, " +  
  33.                         "specify the JVM option '-D{}={}' or call {}.setLevel()",  
  34.                         resourceType, PROP_LEVEL, Level.ADVANCED.name().toLowerCase(), simpleClassName(this));  
  35.             } else {  
  36.                 logger.error(  
  37.                         "LEAK: {}.release() was not called before it's garbage-collected.{}",  
  38.                         resourceType, records);  
  39.             }  
  40.         }  
  41.     }  
  42. }  
综合上面的三段代码,可以看出, Netty 在分配新 ByteBuf 时进行内存泄露检测和报告.

DefaultResourceLeak的声明如下

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. private final class DefaultResourceLeak extends PhantomReference<Object> implements ResourceLeak{  
  2.     //......  
  3.   
  4.     public DefaultResourceLeak(Object referent) {  
  5.         //使用一个静态的引用队列(refQueue)初始化  
  6.         //refQueue是ResourceLeakDecetor的成员变量并由其初始化  
  7.         super(referent, referent != null? refQueue : null);  
  8.         //......  
  9.     }  
  10.   
  11.     //......  
  12. }  

可见DefaultResourceLeak是个”虚”引用类型,有别于常见的普通的”强”引用,虚引用完全不影响目标对象的垃圾回收,但是会在目标对象被VM垃圾回收时被加入到引用队列中.
在正常情况下ResourceLeak对象会所监控的资源的引用计数为0时被清理掉(不在被加入引用队列),所以一旦资源的引用计数失常,ResourceLeak对象会被加入到引用队列.例如没有成对调用ByteBuf的retain和relaease方法,导致ByteBuf没有被正常释放(对于DirectByteBuf没有及时释放内存,对于PooledByteBuf没有返回Pool),当引用队列中存在元素时意味着程序中有内存泄露发生.
ResourceLeakDetector通过检查引用队列来判断是否有内存泄露,并报告跟踪情况.

总结

Netty使用装饰器模式,为ByteBuf增加内存跟踪记录功能.利用虚引用跟踪资源被VM垃圾回收的情况,加上ByteBuf的引用计数特性,进而判断是否发生内存泄露.

本文摘自:http://blog.csdn.net/hadixlin/article/details/19301377

阅读更多
文章标签: Java Netty
个人分类: Java 通用类库
上一篇Java中三个引用类SoftReference 、 WeakReference 和 PhantomReference的区别
下一篇比较全的Netty5类图整理
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭