Java 理论与实践: 用弱引用堵住内存泄漏

要让垃圾收集（GC）回收程序不再使用的对象，对象的逻辑 生命周期（应用程序使用它的时间）和对该对象拥有的引用的实际 生命周期必须是相同的。在大多数时候，好的软件工程技术保证这是自动实现的，不用我们对对象生命周期问题花费过多心思。但是偶尔我们会创建一个引用，它在内存中包含对象的时间比我们预期的要长得多，这种情况称为无意识的对象保留（unintentional object retention）。

创新互联主要从事成都网站设计、做网站、网页设计、企业做网站、公司建网站等业务。立足成都服务南昌,10余年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:028-86922220

无意识对象保留最常见的原因是使用 Map 将元数据与临时对象（transient object）相关联。假定一个对象具有中等生命周期，比分配它的那个方法调用的生命周期长，但是比应用程序的生命周期短，如客户机的套接字连接。需要将一些元数据与这个套接字关联，如生成连接的用户的标识。在创建 Socket 时是不知道这些信息的，并且不能将数据添加到 Socket 对象上，因为不能控制 Socket 类或者它的子类。这时，典型的方法就是在一个全局 Map 中存储这些信息，如清单 1 中的 SocketManager 类所示：

 
 
 
 
      
  
  
  
  1. public class SocketManager {  
    2.   
  
  
  
  2.     private Map< Socket,User> m = new HashMap< Socket,User>();  
    3.   
  
  
  
  3.       
    4.   
  
  
  
  4.     public void setUser(Socket s, User u) {  
    5.   
  
  
  
  5.         m.put(s, u);  
    6.   
  
  
  
  6.     }  
    7.   
  
  
  
  7.     public User getUser(Socket s) {  
    8.   
  
  
  
  8.         return m.get(s);  
    9.   
  
  
  
  9.     }  
    10.   
  
  
  
  10.     public void removeUser(Socket s) {  
    11.   
  
  
  
  11.         m.remove(s);  
    12.   
  
  
  
  12.     }  
    13.   
  
  
  
  13. }  
    14.   
  
  
  
  14. SocketManager socketManager;  
    15.   
  
  
  
  15. ...  
    16.   
  
  
  
  16. socketManager.setUser(socket, user); 
    17.

这种方法的问题是元数据的生命周期需要与套接字的生命周期挂钩，但是除非准确地知道什么时候程序不再需要这个套接字，并记住从 Map 中删除相应的映射，否则，Socket 和 User 对象将会永远留在 Map 中，远远超过响应了请求和关闭套接字的时间。这会阻止 Socket 和 User 对象被垃圾收集，即使应用程序不会再使用它们。这些对象留下来不受控制，很容易造成程序在长时间运行后内存爆满。除了最简单的情况，在几乎所有情况下找出什么时候 Socket 不再被程序使用是一件很烦人和容易出错的任务，需要人工对内存进行管理。

程序有内存泄漏的第一个迹象通常是它抛出一个 OutOfMemoryError，或者因为频繁的垃圾收集而表现出糟糕的性能。幸运的是，垃圾收集可以提供能够用来诊断内存泄漏的大量信息。如果以 -verbose:gc 或者 -Xloggc 选项调用 JVM，那么每次 GC 运行时在控制台上或者日志文件中会打印出一个诊断信息，包括它所花费的时间、当前堆使用情况以及恢复了多少内存。记录 GC 使用情况并不具有干扰性，因此如果需要分析内存问题或者调优垃圾收集器，在生产环境中默认启用 GC 日志是值得的。

有工具可以利用 GC 日志输出并以图形方式将它显示出来，JTune 就是这样的一种工具（请参阅 参考资料）。观察 GC 之后堆大小的图，可以看到程序内存使用的趋势。对于大多数程序来说，可以将内存使用分为两部分：baseline 使用和 current load 使用。对于服务器应用程序，baseline 使用就是应用程序在没有任何负荷、但是已经准备好接受请求时的内存使用，current load 使用是在处理请求过程中使用的、但是在请求处理完成后会释放的内存。只要负荷大体上是恒定的，应用程序通常会很快达到一个稳定的内存使用水平。如果在应用程序已经完成了其初始化并且负荷没有增加的情况下，内存使用持续增加，那么程序就可能在处理前面的请求时保留了生成的对象。

清单 2 展示了一个有内存泄漏的程序。MapLeaker 在线程池中处理任务，并在一个 Map 中记录每一项任务的状态。不幸的是，在任务完成后它不会删除那一项，因此状态项和任务对象（以及它们的内部状态）会不断地积累。

 
 
 
 
      
  
  
  
  1. public class MapLeaker {  
    2.   
  
  
  
  2.     public ExecutorService exec = Executors.newFixedThreadPool(5);  
    3.   
  
  
  
  3.     public Map< Task, TaskStatus> taskStatus   
    4.   
  
  
  
  4.         = Collections.synchronizedMap(new HashMap< Task, TaskStatus>());  
    5.   
  
  
  
  5.     private Random random = new Random();  
    6.   
  
  
  
  6.     private enum TaskStatus { NOT_STARTED, STARTED, FINISHED };  
    7.   
  
  
  
  7.     private class Task implements Runnable {  
    8.   
  
  
  
  8.         private int[] numbers = new int[random.nextInt(200)];  
    9.   
  
  
  
  9.         public void run() {  
    10.   
  
  
  
  10.             int[] temp = new int[random.nextInt(10000)];  
    11.   
  
  
  
  11.             taskStatus.put(this, TaskStatus.STARTED);  
    12.   
  
  
  
  12.             doSomeWork();  
    13.   
  
  
  
  13.             taskStatus.put(this, TaskStatus.FINISHED);  
    14.   
  
  
  
  14.         }  
    15.   
  
  
  
  15.     }  
    16.   
  
  
  
  16.     public Task newTask() {  
    17.   
  
  
  
  17.         Task t = new Task();  
    18.   
  
  
  
  18.         taskStatus.put(t, TaskStatus.NOT_STARTED);  
    19.   
  
  
  
  19.         exec.execute(t);  
    20.   
  
  
  
  20.         return t;  
    21.   
  
  
  
  21.     }  
    22.   
  
  
  
  22. } 
    23.

图 1 显示 MapLeaker GC 之后应用程序堆大小随着时间的变化图。上升趋势是存在内存泄漏的警示信号。（在真实的应用程序中，坡度不会这么大，但是在收集了足够长时间的 GC 数据后，上升趋势通常会表现得很明显。）

确信有了内存泄漏后，下一步就是找出哪种对象造成了这个问题。所有内存分析器都可以生成按照对象类进行分解的堆快照。有一些很好的商业堆分析工具，但是找出内存泄漏不一定要花钱买这些工具 —— 内置的 hprof 工具也可完成这项工作。要使用 hprof 并让它跟踪内存使用，需要以 -Xrunhprof:heap=sites 选项调用 JVM。

清单 3 显示分解了应用程序内存使用的 hprof 输出的相关部分。（hprof 工具在应用程序退出时，或者用 kill -3 或在 Windows 中按 Ctrl+Break 时生成使用分解。）注意两次快照相比，Map.Entry、Task 和 int[] 对象有了显著增加。

 
 
 
 
      
  
  
  
  1. SITES BEGIN (ordered by live bytes) Fri Oct 28 16:30:48 2005  
    2.   
  
  
  
  2.           percent          live          alloc'ed  stack class  
    3.   
  
  
  
  3.  rank   self  accum     bytes objs     bytes  objs trace name 
    4.   
  
  
  
  4.     1 70.13% 70.13%   5694888 13909   5694888 13909 300305 int[]  
    5.   
  
  
  
  5.     2 18.27% 88.40%   1483976   68 278273632 13908 300321 int[]  
    6.   
  
  
  
  6.     3  4.11% 92.51%    333816 13909    333816 13909 300310 java.util.HashMap$Entry  
    7.   
  
  
  
  7.     4  2.74% 95.25%    222544 13909    222544 13909 300304 com.quiotix.dummy.MapLeaker$Task  
    8.   
  
  
  
  8.     5  2.42% 97.67%    196640    2    262192    11 300325 java.util.HashMap$Entry[]  
    9.   
  
  
  
  9.     6  0.66% 98.33%     53680 3355    222464 13904 300324 java.util.concurrent.LinkedBlockingQueue$Node  
    10.   
  
  
  
  10. SITES END 
    11.   
  
  
  
  11. SITES BEGIN (ordered by live bytes) Fri Oct 28 16:31:32 2005  
    12.   
  
  
  
  12.           percent          live          alloc'ed  stack class  
    13.   
  
  
  
  13.  rank   self  accum     bytes objs     bytes  objs trace name 
    14.   
  
  
  
  14.     1 77.07% 77.07%  41176024 100020  41176024 100020 301069 int[]  
    15.   
  
  
  
  15.     2 12.98% 90.05%   6933768  359 2001885688 100020 301093 int[]  
    16.   
  
  
  
  16.     3  4.49% 94.55%   2400480 100020   2400480 100020 301082 java.util.HashMap$Entry  
    17.   
  
  
  
  17.     4  3.00% 97.54%   1600320 100020   1600320 100020 301068 com.quiotix.dummy.MapLeaker$Task  
    18.   
  
  
  
  18.     5  1.96% 99.50%   1048592    1   2097248    14 301104 java.util.HashMap$Entry[]  
    19.   
  
  
  
  19.     6  0.05% 99.55%     25936 1621   1600240 100015 301101 java.util.concurrent.LinkedBlockingQueue$Node  
    20.   
  
  
  
  20. SITES END 
    21.

清单 4 展示了 hprof 输出的另一部分，给出了 Map.Entry 对象的分配点的调用堆栈信息。这个输出告诉我们哪些调用链生成了 Map.Entry 对象，并带有一些程序分析，找出内存泄漏来源一般来说是相当容易的。

 
 
 
 
      
  
  
  
  1. TRACE 300446:  
    2.   
  
  
  
  2.  java.util.HashMap$Entry.< init>(< Unknown Source>:Unknown line)  
    3.   
  
  
  
  3.  java.util.HashMap.addEntry(< Unknown Source>:Unknown line)  
    4.   
  
  
  
  4.  java.util.HashMap.put(< Unknown Source>:Unknown line)  
    5.   
  
  
  
  5.  java.util.Collections$SynchronizedMap.put(< Unknown Source>:Unknown line)  
    6.   
  
  
  
  6.  com.quiotix.dummy.MapLeaker.newTask(MapLeaker.java:48)  
    7.   
  
  
  
  7.  com.quiotix.dummy.MapLeaker.main(MapLeaker.java:64) 
    8.

SocketManager 的问题是 Socket-User 映射的生命周期应当与 Socket 的生命周期相匹配，但是语言没有提供任何容易的方法实施这项规则。这使得程序不得不使用人工内存管理的老技术。幸运的是，从 JDK 1.2 开始，垃圾收集器提供了一种声明这种对象生命周期依赖性的方法，这样垃圾收集器就可以帮助我们防止这种内存泄漏 —— 利用弱引用。

#p#

弱引用是对一个对象（称为 referent）的引用的持有者。使用弱引用后，可以维持对 referent 的引用，而不会阻止它被垃圾收集。当垃圾收集器跟踪堆的时候，如果对一个对象的引用只有弱引用，那么这个 referent 就会成为垃圾收集的候选对象，就像没有任何剩余的引用一样，而且所有剩余的弱引用都被清除。（只有弱引用的对象称为弱可及（weakly reachable）。）

WeakReference 的 referent 是在构造时设置的，在没有被清除之前，可以用 get() 获取它的值。如果弱引用被清除了（不管是 referent 已经被垃圾收集了，还是有人调用了 WeakReference.clear()），get() 会返回 null。相应地，在使用其结果之前，应当总是检查 get() 是否返回一个非 null 值，因为 referent 最终总是会被垃圾收集的。

用一个普通的（强）引用拷贝一个对象引用时，限制 referent 的生命周期至少与被拷贝的引用的生命周期一样长。如果不小心，那么它可能就与程序的生命周期一样 —— 如果将一个对象放入一个全局集合中的话。另一方面，在创建对一个对象的弱引用时，完全没有扩展 referent 的生命周期，只是在对象仍然存活的时候，保持另一种到达它的方法。

弱引用对于构造弱集合最有用，如那些在应用程序的其余部分使用对象期间存储关于这些对象的元数据的集合 —— 这就是 SocketManager 类所要做的工作。因为这是弱引用最常见的用法，WeakHashMap 也被添加到 JDK 1.2 的类库中，它对键（而不是对值）使用弱引用。如果在一个普通 HashMap 中用一个对象作为键，那么这个对象在映射从 Map 中删除之前不能被回收，WeakHashMap 使您可以用一个对象作为 Map 键，同时不会阻止这个对象被垃圾收集。清单 5 给出了 WeakHashMap 的 get() 方法的一种可能实现，它展示了弱引用的使用：

 
 
 
 
      
  
  
  
  1. public class WeakHashMap< K,V> implements Map< K,V> {  
    2.   
  
  
  
  2.     private static class Entry< K,V> extends WeakReference< K>   
    3.   
  
  
  
  3.       implements Map.Entry< K,V> {  
    4.   
  
  
  
  4.         private V value;  
    5.   
  
  
  
  5.         private final int hash;  
    6.   
  
  
  
  6.         private Entry< K,V> next;  
    7.   
  
  
  
  7.         ...  
    8.   
  
  
  
  8.     }  
    9.   
  
  
  
  9.     public V get(Object key) {  
    10.   
  
  
  
  10.         int hash = getHash(key);  
    11.   
  
  
  
  11.         Entry< K,V> e = getChain(hash);  
    12.   
  
  
  
  12.         while (e != null) {  
    13.   
  
  
  
  13.             K eKey= e.get();  
    14.   
  
  
  
  14.             if (e.hash == hash && (key == eKey || key.equals(eKey)))  
    15.   
  
  
  
  15.                 return e.value;  
    16.   
  
  
  
  16.             e = e.next;  
    17.   
  
  
  
  17.         }  
    18.   
  
  
  
  18.         return null;  
    19.   
  
  
  
  19.     } 
    20.

调用 WeakReference.get() 时，它返回一个对 referent 的强引用（如果它仍然存活的话），因此不需要担心映射在 while 循环体中消失，因为强引用会防止它被垃圾收集。WeakHashMap 的实现展示了弱引用的一种常见用法 —— 一些内部对象扩展 WeakReference。其原因在下面一节讨论引用队列时会得到解释。

在向 WeakHashMap 中添加映射时，请记住映射可能会在以后“脱离”，因为键被垃圾收集了。在这种情况下，get() 返回 null，这使得测试 get() 的返回值是否为 null 变得比平时更重要了。

用 WeakHashMap 堵住泄漏

在 SocketManager 中防止泄漏很容易，只要用 WeakHashMap 代替 HashMap 就行了，如清单 6 所示。（如果 SocketManager 需要线程安全，那么可以用 Collections.synchronizedMap() 包装 WeakHashMap）。当映射的生命周期必须与键的生命周期联系在一起时，可以使用这种方法。不过，应当小心不滥用这种技术，大多数时候还是应当使用普通的 HashMap 作为 Map 的实现。

 
 
 
 
      
  
  
  
  1. public class SocketManager {  
    2.   
  
  
  
  2.     private Map< Socket,User> m = new WeakHashMap< Socket,User>();  
    3.   
  
  
  
  3.       
    4.   
  
  
  
  4.     public void setUser(Socket s, User u) {  
    5.   
  
  
  
  5.         m.put(s, u);  
    6.   
  
  
  
  6.     }  
    7.   
  
  
  
  7.     public User getUser(Socket s) {  
    8.   
  
  
  
  8.         return m.get(s);  
    9.   
  
  
  
  9.     }  
    10.   
  
  
  
  10. } 
    11.

WeakHashMap 用弱引用承载映射键，这使得应用程序不再使用键对象时它们可以被垃圾收集，get() 实现可以根据 WeakReference.get() 是否返回 null 来区分死的映射和活的映射。但是这只是防止 Map 的内存消耗在应用程序的生命周期中不断增加所需要做的工作的一半，还需要做一些工作以便在键对象被收集后从 Map 中删除死项。否则，Map 会充满对应于死键的项。虽然这对于应用程序是不可见的，但是它仍然会造成应用程序耗尽内存，因为即使键被收集了，Map.Entry 和值对象也不会被收集。

可以通过周期性地扫描 Map，对每一个弱引用调用 get()，并在 get() 返回 null 时删除那个映射而消除死映射。但是如果 Map 有许多活的项，那么这种方法的效率很低。如果有一种方法可以在弱引用的 referent 被垃圾收集时发出通知就好了，这就是引用队列 的作用。

引用队列是垃圾收集器向应用程序返回关于对象生命周期的信息的主要方法。弱引用有两个构造函数：一个只取 referent 作为参数，另一个还取引用队列作为参数。如果用关联的引用队列创建弱引用，在 referent 成为 GC 候选对象时，这个引用对象（不是 referent）就在引用清除后加入 到引用队列中。之后，应用程序从引用队列提取引用并了解到它的 referent 已被收集，因此可以进行相应的清理活动，如去掉已不在弱集合中的对象的项。（引用队列提供了与 BlockingQueue 同样的出列模式 —— polled、timed blocking 和 untimed blocking。）

WeakHashMap 有一个名为 expungeStaleEntries() 的私有方法，大多数 Map 操作中会调用它，它去掉引用队列中所有失效的引用，并删除关联的映射。清单 7 展示了 expungeStaleEntries() 的一种可能实现。用于存储键-值映射的 Entry 类型扩展了 WeakReference，因此当 expungeStaleEntries() 要求下一个失效的弱引用时，它得到一个 Entry。用引用队列代替定期扫描内容的方法来清理 Map 更有效，因为清理过程不会触及活的项，只有在有实际加入队列的引用时它才工作。

 
 
 
 
      
  
  
  
  1. private void expungeStaleEntries() {  
    2.   
  
  
  
  2. ry< K,V> e;  
    3.   
  
  
  
  3.     while ( (e = (Entry< K,V>) queue.poll()) != null) {  
    4.   
  
  
  
  4.         int hash = e.hash;  
    5.   
  
  
  
  5.         Entry< K,V> prev = getChain(hash);  
    6.   
  
  
  
  6.         Entry< K,V> cur = prev;  
    7.   
  
  
  
  7.         while (cur != null) {  
    8.   
  
  
  
  8.             Entry< K,V> next = cur.next;  
    9.   
  
  
  
  9.             if (cur == e) {  
    10.   
  
  
  
  10.                 if (prev == e)  
    11.   
  
  
  
  11.                     setChain(hash, next);  
    12.   
  
  
  
  12.                 else 
    13.   
  
  
  
  13.                     prev.next = next;  
    14.   
  
  
  
  14.                 break;  
    15.   
  
  
  
  15.             }  
    16.   
  
  
  
  16.             prev = cur;  
    17.   
  
  
  
  17.             cur = next;  
    18.   
  
  
  
  18.         }  
    19.   
  
  
  
  19.     }  
    20.   
  
  
  
  20. } 
    21.

弱引用和弱集合是对堆进行管理的强大工具，使得应用程序可以使用更复杂的可及性方案，而不只是由普通（强）引用所提供的“要么全部要么没有”可及性。

【编辑推荐】

  1. Java内存泄漏的检测和处理
  2. 几种典型的Java内存泄漏
  3. 详细介绍Java的内存管理与内存泄露
  4. Java程序性能优化之找出内存溢出元凶
  5. 20个开发人员非常有用的Java功能代码

文章题目：Java 理论与实践: 用弱引用堵住内存泄漏
文章源于：http://www.shufengxianlan.com/qtweb/news23/145123.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

响应式网站知识

分类信息网

兴宏源活动板房　　 　鑫友邦火锅桌　　 　成都茶叶销售　　 　成都网络推广　　 　全网营销　　 　云主机　　 　成都网站设计　　 　成都网站推广　　 　网站排名　　 　ssl数字证书　　 　成都网站维护公司　　 　成都康明斯发电机　　 　节能环保网站建设方案　　 　中国电信成都枢纽中心　　 　成都主机托管　　 　微信公众号开发　　 　成都微信开发　　 　成都众诚伟业　　 　成都网站推广　　 　腾讯云香港免备案空间