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
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }
    
    
    /**
     * 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
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    
    /**
     * 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;
    }

     /**
      * Construct a new map initially containing (firstKey, firstValue).
      * ThreadLocalMaps are constructed lazily, so we only create
      * one when we have at least one entry to put in it.
      */
     ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
         // 和HashMap相同，内部是一个Entry数组,默认初始化长度为16
         table = new Entry[INITIAL_CAPACITY];
         // 算出ThreadLocal在数组里面的所在位置
         int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
         // 把K,V组成的Entry扔到数组里
         table[i] = new Entry(firstKey, firstValue);
         size = 1;
         // 设置扩容的阈值
         setThreshold(INITIAL_CAPACITY);
     }
     
     /**
      * Set the resize threshold to maintain at worst a 2/3 load factor.
      */
     private void setThreshold(int len) {
         threshold = len * 2 / 3;
     }

private void set(ThreadLocal<?> key, Object value) {
    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();
}

    public static void main(String[] args) {
        ThreadLocal<String> threadLocal = new ThreadLocal<>();
        try {
            threadLocal.set("MistRay");
            // 消除ThreadLocal的强引用
            threadLocal = null;
            System.gc();
            Thread.sleep(20000);
            Thread thread = Thread.currentThread();
            System.out.println(thread);
        } catch (Exception e) {
            System.out.println(1111);
        } finally {
            threadLocal.remove();
        }
    }

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

    ThreadLocal<String> threadLocal = new ThreadLocal();
    try {
        threadLocal.set("MistRay");
    } finally {
        threadLocal.remove();
    }