转：Java内存储器泄露的理解与解决

Java内存管理机制

在C++语言中，如果需要动态分配一块内存，程序员需要负责这块内存的整个生命周期。从申请分配、到使用、再到最后的释放。这样的过程非常灵活，但是却十分繁琐，程序员很容易由于疏忽而忘记释放内存，从而导致内存的泄露。Java语言对内存管理做了自己的优化，这就是垃圾回收机制。Java的几乎所有内存对象都是在堆内存上分配（基本数据类型除外），然后由GC（garbage collection）负责自动回收不再使用的内存。

    上面是Java内存管理机制的基本情况。但是如果仅仅理解到这里，我们在实际的项目开发中仍然会遇到内存泄漏的问题。也许有人表示怀疑，既然Java的垃圾回收机制能够自动的回收内存，怎么还会出现内存泄漏的情况呢？这个问题，我们需要知道GC在什么时候回收内存对象，什么样的内存对象会被GC认为是“不再使用”的。

    Java中对内存对象的访问，使用的是引用的方式。在Java代码中我们维护一个内存对象的引用变量，通过这个引用变量的值，我们可以访问到对应的内存地址中的内存对象空间。在Java程序中，这个引用变量本身既可以存放堆内存中，又可以放在代码栈的内存中（与基本数据类型相同）。GC线程会从代码栈中的引用变量开始跟踪，从而判定哪些内存是正在使用的。如果GC线程通过这种方式，无法跟踪到某一块堆内存，那么GC就认为这块内存将不再使用了（因为代码中已经无法访问这块内存了）。

通过这种有向图的内存管理方式，当一个内存对象失去了所有的引用之后，GC就可以将其回收。反过来说，如果这个对象还存在引用，那么它将不会被GC回收，哪怕是Java虚拟机抛出OutOfMemoryError。

Java内存泄露

    一般来说内存泄漏有两种情况。一种情况如在C/C++语言中的，在堆中的分配的内存，在没有将其释放掉的时候，就将所有能访问这块内存的方式都删掉（如指针重新赋值）；另一种情况则是在内存对象明明已经不需要的时候，还仍然保留着这块内存和它的访问方式（引用）。第一种情况，在Java中已经由于垃圾回收机制的引入，得到了很好的解决。所以，Java中的内存泄漏，主要指的是第二种情况。

    可能光说概念太抽象了，大家可以看一下这样的例子：

 Vector v=new Vector(10);
 for (int i=1;i<100; i++){
 Object o=new Object();
 v.add(o);
 o=null;
}

在这个例子中，代码栈中存在Vector对象的引用v和Object对象的引用o。在For循环中，我们不断的生成新的对象，然后将其添加到Vector对象中，之后将o引用置空。问题是当o引用被置空后，如果发生GC，我们创建的Object对象是否能够被GC回收呢？答案是否定的。因为，GC在跟踪代码栈中的引用时，会发现v引用，而继续往下跟踪，就会发现v引用指向的内存空间中又存在指向Object对象的引用。也就是说尽管o引用已经被置空，但是Object对象仍然存在其他的引用，是可以被访问到的，所以GC无法将其释放掉。如果在此循环之后，Object对象对程序已经没有任何作用，那么我们就认为此Java程序发生了内存泄漏。

    尽管对于C/C++中的内存泄露情况来说，Java内存泄露导致的破坏性小，除了少数情况会出现程序崩溃的情况外，大多数情况下程序仍然能正常运行。但是，在移动设备对于内存和CPU都有较严格的限制的情况下，Java的内存溢出会导致程序效率低下、占用大量不需要的内存等问题。这将导致整个机器性能变差，严重的也会引起抛出OutOfMemoryError，导致程序崩溃。

一般情况下内存泄漏的避免

    在不涉及复杂数据结构的一般情况下，Java的内存泄露表现为一个内存对象的生命周期超出了程序需要它的时间长度。我们有时也将其称为“对象游离”。

例如：

public class FileSearch{
 
     private byte[] content;
     private File mFile;
     
     public FileSearch(File file){
         mFile = file;
     }
 
     public boolean hasString(String str){
         int size = getFileSize(mFile);
         content = new byte[size];
         loadFile(mFile, content);
         
         String s = new String(content);
         return s.contains(str);
     }
}

    String str = new String("hello"); //①
    ReferenceQueue<String> rq = new ReferenceQueue<String>(); //②
    WeakReference<String> wf = new WeakReference<String>(str, rq); //③
    str=null; //④取消"hello"对象的强引用
    String str1=wf.get(); //⑤假如"hello"对象没有被回收，str1引用"hello"对象
    //假如"hello"对象没有被回收，rq.poll()返回null
    Reference<? extends String> ref=rq.poll(); //⑥

package com.***.widget;
  2
  3//: SoftHashMap.java 
  4import java.util.*; 
  5import java.lang.ref.*; 
  6
  7import android.util.Log;
  8
  9public class SoftHashMap extends AbstractMap { 
 10  /** The internal HashMap that will hold the SoftReference. */ 
 11  private final Map hash = new HashMap(); 
 12  /** The number of "hard" references to hold internally. */ 
 13  private final int HARD_SIZE; 
 14  /** The FIFO list of hard references, order of last access. */ 
 15  private final LinkedList hardCache = new LinkedList(); 
 16  /** Reference queue for cleared SoftReference objects. */ 
 17  private ReferenceQueue queue = new ReferenceQueue(); 
 18
 19  //Strong Reference number
 20  public SoftHashMap() { this(100); } 
 21  public SoftHashMap(int hardSize) { HARD_SIZE = hardSize; } 
 22  
 23
 24  public Object get(Object key) { 
 25    Object result = null; 
 26    // We get the SoftReference represented by that key 
 27    SoftReference soft_ref = (SoftReference)hash.get(key); 
 28    if (soft_ref != null) { 
 29      // From the SoftReference we get the value, which can be 
 30      // null if it was not in the map, or it was removed in 
 31      // the processQueue() method defined below 
 32      result = soft_ref.get(); 
 33      if (result == null) { 
 34        // If the value has been garbage collected, remove the 
 35        // entry from the HashMap. 
 36        hash.remove(key); 
 37      } else { 
 38        // We now add this object to the beginning of the hard 
 39        // reference queue.  One reference can occur more than 
 40        // once, because lookups of the FIFO queue are slow, so 
 41        // we don't want to search through it each time to remove 
 42        // duplicates. 
 43          //keep recent use object in memory
 44        hardCache.addFirst(result); 
 45        if (hardCache.size() > HARD_SIZE) { 
 46          // Remove the last entry if list longer than HARD_SIZE 
 47          hardCache.removeLast(); 
 48        } 
 49      } 
 50    } 
 51    return result; 
 52  } 
 53
 54  /** We define our own subclass of SoftReference which contains 
 55   not only the value but also the key to make it easier to find 
 56   the entry in the HashMap after it's been garbage collected. */ 
 57  private static class SoftValue extends SoftReference { 
 58    private final Object key; // always make data member final 
 59    /** Did you know that an outer class can access private data 
 60     members and methods of an inner class?  I didn't know that! 
 61     I thought it was only the inner class who could access the 
 62     outer class's private information.  An outer class can also 
 63     access private members of an inner class inside its inner 
 64     class. */ 
 65    private SoftValue(Object k, Object key, ReferenceQueue q) { 
 66      super(k, q); 
 67      this.key = key; 
 68    } 
 69  } 
 70
 71  /** Here we go through the ReferenceQueue and remove garbage 
 72   collected SoftValue objects from the HashMap by looking them 
 73   up using the SoftValue.key data member. */ 
 74  public void processQueue() { 
 75    SoftValue sv; 
 76    while ((sv = (SoftValue)queue.poll()) != null) { 
 77        if(sv.get()== null){
 78            Log.e("processQueue", "null");
 79        }else{
 80            Log.e("processQueue", "Not null");
 81        }
 82      hash.remove(sv.key); // we can access private data!
 83      Log.e("SoftHashMap", "release " + sv.key);
 84    } 
 85  } 
 86  /** Here we put the key, value pair into the HashMap using 
 87   a SoftValue object. */ 
 88  public Object put(Object key, Object value) { 
 89    processQueue(); // throw out garbage collected values first 
 90    Log.e("SoftHashMap", "put into " + key);
 91    return hash.put(key, new SoftValue(value, key, queue)); 
 92  } 
 93  public Object remove(Object key) { 
 94    processQueue(); // throw out garbage collected values first 
 95    return hash.remove(key); 
 96  } 
 97  public void clear() { 
 98    hardCache.clear(); 
 99    processQueue(); // throw out garbage collected values 
100    hash.clear(); 
101  } 
102  public int size() { 
103    processQueue(); // throw out garbage collected values first 
104    return hash.size(); 
105  } 
106  public Set entrySet() { 
107    // no, no, you may NOT do that!!! GRRR 
108    throw new UnsupportedOperationException(); 
109  } 
110} 

参考文献

Java 内存管理原理、内存泄漏实例及解决方案研究

Java中的强引用、软引用、弱引用和虚引用

垃圾回收与强引用，软引用，弱引用，幻引用的关系