ThreadLocal內部是如何為每一個線程維護變量副本的呢？
在ThreadLocal類中有一個靜態內部類ThreadLocalMap(概念上類似于Map)，用鍵值對的形式存儲每一個線程的變量副本，ThreadLocalMap中元素的key為當前ThreadLocal對象，而value對應線程的變量副本，每個線程可能存在多個ThreadLocal。

    /**
     * Returns the value in the current thread"s copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread"s value of this thread-local
     */
    public T get() {
        Thread t = Thread.currentThread();    //當前線程
        ThreadLocalMap map = getMap(t);    //獲取當前線程對應的ThreadLocalMap
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);    //獲取對應ThreadLocal的變量值
            if (e != null)
                return (T)e.value;
        }
        return setInitialValue();    //若當前線程還未創建ThreadLocalMap，則返回調用此方法并在其中調用createMap方法進行創建并返回初始值。
    }

    // 是調用當期線程t，返回當前線程t中的一個成員變量threadLocals。
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    // java.lang.Thread類下， 實際上就是一個ThreadLocalMap
    ThreadLocal.ThreadLocalMap threadLocals = null;


    /**
     * Variant of set() to establish initialValue. Used instead
     * of set() in case user has overridden the set() method.
     *
     * @return the initial value
     */
    private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }


    /**
     * 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);
    }


    /**
     * Create the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     * @param map the map to store.
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }


    /**
     * Removes the current thread"s value for this thread-local
     * variable.  If this thread-local variable is subsequently
     * {@linkplain #get read} by the current thread, its value will be
     * reinitialized by invoking its {@link #initialValue} method,
     * unless its value is {@linkplain #set set} by the current thread
     * in the interim.  This may result in multiple invocations of the
     * initialValue method in the current thread.
     *
     * @since 1.5
     */
     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

上述是在ThreadLocal類中的幾個主要的方法，他們的核心都是對其內部類ThreadLocalMap進行操作，下面看一下該類的源代碼：

static class ThreadLocalMap {

 //map中的每個節點Entry,其鍵key是ThreadLocal并且還是弱引用，這也導致了后續會產生內存泄漏問題的原因。
 static class Entry extends WeakReference> {
           Object value;
           Entry(ThreadLocal k, Object v) {
               super(k);
               value = v;
   }
    /**
     * 初始化容量為16，以為對其擴充也必須是2的指數 
     */
    private static final int INITIAL_CAPACITY = 16;

    /**
     * 真正用于存儲線程的每個ThreadLocal的數組，將ThreadLocal和其對應的值包裝為一個Entry。
     */
    private Entry[] table;


    ///....其他的方法和操作都和map的類似
}

這個問題很容易解釋，因為一個線程中可以有多個ThreadLocal對象，所以ThreadLocalMap中可以有多個鍵值對，存儲多個value值，而如果使用線程id作為key，那就只有一個鍵值對了。

首先要理解內存泄露（memory leak）和內存溢出（out of memory）的區別。內存溢出是因為在內存中創建了大量在引用的對象，導致后續再申請內存時沒有足夠的內存空間供其使用。內存泄露是指程序申請完內存后，無法釋放已申請的內存空間，（不再使用的對象或者變量仍占內存空間）。

根據上面Entry方法的源碼，我們知道ThreadLocalMap是使用ThreadLocal的弱引用作為Key的。下圖是本文介紹到的一些對象之間的引用關系圖，實線表示強引用，虛線表示弱引用：

如上圖，ThreadLocalMap使用ThreadLocal的弱引用作為key，如果一個ThreadLocal沒有外部強引用引用他，那么系統gc的時候，這個ThreadLocal勢必會被回收，這樣一來，ThreadLocalMap中就會出現key為null的Entry，就沒有辦法訪問這些key為null的Entry的value，如果當前線程再遲遲不結束的話，這些key為null的Entry的value就會一直存在一條強引用鏈：

Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value

永遠無法回收，造成內存泄露。
只有當前thread結束以后, Thread Ref就不會存在棧中,強引用斷開, Thread, ThreadLocalMap, Entry將全部被GC回收。但如果是線程對象不被回收的情況，比如使用線程池，線程結束是不會銷毀的，就可能出現真正意義上的內存泄露。

ThreadLocalMap設計時的對上面問題的對策：
當我們仔細讀過ThreadLocalMap的源碼，我們可以推斷，如果在使用的ThreadLocal的過程中，顯式地進行remove是個很好的編碼習慣，這樣是不會引起內存泄漏。
那么如果沒有顯式地進行remove呢？只能說如果對應線程之后調用ThreadLocal的get和set方法都有很高的概率會順便清理掉無效對象，斷開value強引用，從而大對象被收集器回收。

但無論如何，我們應該考慮到何時調用ThreadLocal的remove方法。一個比較熟悉的場景就是對于一個請求一個線程的server如tomcat，在代碼中對web api作一個切面，存放一些如用戶名等用戶信息，在連接點方法結束后，再顯式調用remove。

啟動兩個線程，第一個線程中存儲的userid為1，第二個線程中存儲的userid為2。

package com.lzumetal.multithread.threadlocal;

import java.math.BigDecimal;

public class ThreadLocalTest {

    public static void main(String[] args) throws InterruptedException {
        Order order01 = new Order(1, 1, new BigDecimal(10), 1);
        new Thread(new OrderHandler(1, order01)).start();

        Order order02 = new Order(2, 2, new BigDecimal(20), 2);
        new Thread(new OrderHandler(2, order02)).start();
    }
}

package com.lzumetal.multithread.threadlocal;

public class OrderHandler implements Runnable {

    private static OrderService orderService = new OrderService();

    private Integer userId;
    private Order order;

    public OrderHandler(Integer userId, Order order) {
        this.userId = userId;
        this.order = order;
    }

    @Override
    public void run() {
        EnvUtil.getUserIdContext().set(userId);
        orderService.addOrder(order);
        orderService.updateStock(order.getGoodId(), order.getGoodCount());
    }
}

package com.lzumetal.multithread.threadlocal;

public class OrderService {


    /**
     * 新增訂單
     *
     * @param order
     */
    public void addOrder(Order order) {
        Integer userId = EnvUtil.getUserIdContext().get();
        System.out.println(Thread.currentThread().getName() + "新增訂單服務中獲取用戶id-->" + userId);
    }


    /**
     * 更新庫存
     *
     * @param goodId
     * @param goodCount
     */
    public void updateStock(Integer goodId, Integer goodCount) {
        //雖然更新庫存不需要關注userId，但是在這里也一樣能夠獲取到
        Integer userId = EnvUtil.getUserIdContext().get();
        System.out.println(Thread.currentThread().getName() + "在更新庫存中獲取用戶id-->" + userId);
    }


}

Thread-0新增訂單服務中獲取用戶id-->1
Thread-1新增訂單服務中獲取用戶id-->2
Thread-0在更新庫存中獲取用戶id-->1
Thread-1在更新庫存中獲取用戶id-->2