ThreadLocal是否会引起内存溢出？

最近碰到一个使用ThreadLocal时因为未调用remove()而险些引起内存溢出的问题，所以看了下ThreadLocal的源码，结合线程池原理做一个简单的分析，确认是否最终会导致内存溢出。

既然是因为没调用remove()方法而险些导致内存溢出，那首先看下remove()方法中做了什么。

Java代码


 




public void remove() {   
        ThreadLocalMap m = getMap(Thread.currentThread());   
        if (m != null)   
            m.remove(this);   
    }  

public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}

从remove()的实现来看就是一个map.remove()的调用。既然不调用map.remove()可能会引起内存溢出的话，就需要看看ThreadLocalMap的实现了。

Java代码


 




 /**  
  * ThreadLocalMap is a customized hash map suitable only for
 
  * maintaining thread local values. No operations are exported
 
  * outside of the ThreadLocal class. The class is package private to
 
  * allow declaration of fields in class Thread.  To help deal with
 
  * very large and long-lived usages, the hash table entries use
 
  * WeakReferences for keys. However, since reference queues are not
 
  * used, stale entries are guaranteed to be removed only when
 
  * the table starts running out of space.
 
  */  
 static class ThreadLocalMap {   
  
     /**  
      * The entries in this hash map extend WeakReference, using
 
      * its main ref field as the key (which is always a
 
      * ThreadLocal object).  Note that null keys (i.e. entry.get()
 
      * == null) mean that the key is no longer referenced, so the
 
      * entry can be expunged from table.  Such entries are referred to
 
      * as "stale entries" in the code that follows.
 
      */  
     static class Entry extends WeakReference<ThreadLocal> {   
         /** The value associated with this ThreadLocal. */  
         Object value;   
  
         Entry(ThreadLocal k, Object v) {   
             super(k);   
             value = v;   
         }   
     }   
  
     /**  
      * The initial capacity -- MUST be a power of two.
 
      */  
     private static final int INITIAL_CAPACITY = 16;
  
  
     /**  
      * The table, resized as necessary.  
      * table.length MUST always be a power of two.
 
      */  
     private Entry[] table;   
  
     /**  
      * The number of entries in the table.
 
      */  
     private int size = 0;   
  
     /**  
      * The next size value at which to resize.
 
      */  
     private int threshold; // Default to 0
  
  
     /**  
      * Set the resize threshold to maintain at worst a 2/3 load factor.
 
      */  
     private void setThreshold(int len) {   
         threshold = len * 2 / 3;   
     }