Java内存泄露的理解与解决

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

 1  public   class  FileSearch{
 2  
 3       private   byte [] content;
 4       private  File mFile;
 5      
 6       public  FileSearch(File file){
 7          mFile  =  file;
 8      }
 9  
10       public   boolean  hasString(String str){
11           int  size  =  getFileSize(mFile);
12          content  =   new   byte [size];
13          loadFile(mFile, content);
14          
15          String s  =   new  String(content);
16           return  s.contains(str);
17      }
18  }

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

  1  package  com. *** .widget;
  2 
  3   // : SoftHashMap.java  
  4   import  java.util. * ; 
  5   import  java.lang.ref. * ; 
  6 
  7   import  android.util.Log;
  8 
  9   public   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   }  
111 
112 
113