[[416507]]

本文轉(zhuǎn)載自微信公眾號「三不猴子」，作者sanbuhouzi。轉(zhuǎn)載本文請聯(lián)系三不猴子公眾號。

為什么ThreadLocal容易導致內(nèi)存泄漏?

ThreadLocal是什么?

官方解釋為：

This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its get or set method) has its own, independently initialized copy of the variable.

我們通常創(chuàng)建的變量可以被任何線程訪問和修改，而是用ThreadLocal創(chuàng)建的變量只能通過當前線程去訪問和修改。

ThreadLocal原理

jdk版本1.8，我們先看一下ThreadLocal的源碼，先從set方法開始。

/** 
   * Sets the current thread's copy of this thread-local variable 
   * to the specified value.  Most subclasses will have no need to 
   * override this method, relying solely on the {@link #initialValue} 
   * method to set the values of thread-locals. 
   * 
   * @param value the value to be stored in the current thread's copy of 
   *        this thread-local. 
   */ 
  public void set(T value) { 
      Thread t = Thread.currentThread(); 
      ThreadLocalMap map = getMap(t); 
      if (map != null) 
          map.set(this, value); 
      else 
          createMap(t, value); 
  } 

這個ThreadLocalMap是ThreadLocal的一個內(nèi)部類，key是當前Thread對象，value是我們要存的對象。首先拿到當前線程對象，然后獲取了個map，然后往這個map中放了當前ThreadLocal對象，如果map為空則創(chuàng)建一個map?？纯磄etMap的邏輯。

/** 
    * Get the map associated with a ThreadLocal. Overridden in 
    * InheritableThreadLocal. 
    * 
    * @param  t the current thread 
    * @return the map 
    */ 
   ThreadLocalMap getMap(Thread t) { 
       return t.threadLocals; 
   } 

getMap就是在Thread成員變量中獲取一個map。往下就是ThreadLocalMap.set()看看set的邏輯。

/** 
     * Set the value associated with key. 
     * 
     * @param key the thread local object 
     * @param value the value to be set 
     */ 
    private void set(ThreadLocal<?> key, Object value) { 
 
        // We don't use a fast path as with get() because it is at 
        // least as common to use set() to create new entries as 
        // it is to replace existing ones, in which case, a fast 
        // path would fail more often than not. 
 
        Entry[] tab = table; 
        int len = tab.length; 
        int i = key.threadLocalHashCode & (len-1); 
 
        for (Entry e = tab[i]; 
             e != null; 
             e = tab[i = nextIndex(i, len)]) { 
            ThreadLocal<?> k = e.get(); 
 
            if (k == key) { 
                e.value = value; 
                return; 
            } 
 
            if (k == null) { 
                replaceStaleEntry(key, value, i); 
                return; 
            } 
        } 
 
        tab[i] = new Entry(key, value); 
        int sz = ++size; 
        if (!cleanSomeSlots(i, sz) && sz >= threshold) 
            rehash(); 
    } 

這里構(gòu)造了個Entry對象，這個Entry可以看成是map的一行數(shù)據(jù)，一個key-value對。再看看Entry的源碼。

static class Entry extends WeakReference<ThreadLocal<?>> { 
            /** The value associated with this ThreadLocal. */ 
            Object value; 
 
            Entry(ThreadLocal<?> k, Object v) { 
                super(k); 
                value = v; 
            } 
        } 

這個Entry對象竟然是繼承了WeakReference對象。上面的流程用圖畫出來就是這樣的。

總結(jié)起來就是：

• 每個Thread維護著一個ThreadLocalMap的引用
• ThreadLocalMap是ThreadLocal的內(nèi)部類，用Entry來進行存儲
• 調(diào)用ThreadLocal的set()方法時，實際上就是往ThreadLocalMap設置值，key是ThreadLocal對象，value是傳遞進來的對象
• 調(diào)用ThreadLocal的get()方法時，實際上就是往ThreadLocalMap獲取值，key是ThreadLocal對象

ThreadLocal本身并不存儲值，它只是作為一個key來讓線程從ThreadLocalMap獲取value。

什么是弱引用呢? 為什么ThreadLocal要使用弱引用呢?

官方文檔解釋為：

/** 
 * Weak reference objects, which do not prevent their referents from being 
 * made finalizable, finalized, and then reclaimed.  Weak references are most 
 * often used to implement canonicalizing mappings. 
 * 
 * <p> Suppose that the garbage collector determines at a certain point in time 
 * that an object is <a href="package-summary.html#reachability">weakly 
 * reachable</a>.  At that time it will atomically clear all weak references to 
 * that object and all weak references to any other weakly-reachable objects 
 * from which that object is reachable through a chain of strong and soft 
 * references.  At the same time it will declare all of the formerly 
 * weakly-reachable objects to be finalizable.  At the same time or at some 
 * later time it will enqueue those newly-cleared weak references that are 
 * registered with reference queues. 
 * 
 * @author   Mark Reinhold 
 * @since    1.2 
 */ 

就是不會被程序計數(shù)器計數(shù)的引用，所以在垃圾回收器回收的時候不管是否有引用都會被回收。由于垃圾回收器是一個優(yōu)先級很低的線程，因此不一定會很快發(fā)現(xiàn)那些只具有弱引用的對象。

ThreadLocal為什么要使用弱引用?

因為當我們存入的對象被置為null的時候，也就是ThreadLocalMap的value為null，ThreadLocalMap的key是弱引用此時在下一次垃圾回收器回收垃圾的時候就可以回收掉這個key-value也是就一個Entry對象了。

既然弱引用是有助于垃圾回收的，那為什么ThreadLocal還是容易導致內(nèi)存泄漏?

弱引用確實是有助于垃圾回收，但是也是有弊端的，假設我們現(xiàn)在存入了一個對象，此時虛擬機gc，將key弱引用回收，但是value依然是強引用，key被回收了，這個value無法通過通過ThreadLocal對象的get方法獲取，它永遠不會被訪問到了，所以存在內(nèi)存泄漏的風險。

如何避免內(nèi)存泄漏

• 在ThreadLocal使用前后都調(diào)用remove清理，同時對異常情況也要在finally中清理。 
• 盡量不要使用全局的ThreadLocal，靜態(tài)變量的生命周期和類的生命周期是一致的，而類的卸載時機可以說比較苛刻，這會導致靜態(tài)ThreadLocal無法被垃圾回收，容易出現(xiàn)內(nèi)存泄漏。