ThreadLocal 问题

Thread 类

public class Thread implements Runnable {
	// 存放当前线程的ThreadLocal对象及其value
    ThreadLocal.ThreadLocalMap threadLocals = null;
}

ThreadLocal类

public class ThreadLocal {
	// get 方法
    public T get() {
        Thread t = Thread.currentThread();
        // 获取当前线程的ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        if (map != null) {
        	// 用当前ThreadLocal对象去当前线程的ThreadLocalMap里去找
            ThreadLocalMap.Entry e = map.getEntry(this);
            // 找到就返回
            if (e != null) {
                T result = (T)e.value;
                return result;
            }
        }
        // 找不到，就调用初始化方法
        return setInitialValue();
    }
    static class ThreadLocalMap {
        private Entry getEntry(ThreadLocal key) {
        	// 通过hash计算获取下标
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            // 如果该下标有值，且是当前key。则返回
            if (e != null && e.get() == key)
                return e;
            else
            	// 否则向后遍历数组查找
                return getEntryAfterMiss(key, i, e);
        }
        private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;
			// 从该下标向后遍历查找。
            while (e != null) {
                ThreadLocal k = e.get();
                // 是当前key则返回
                if (k == key)
                    return e;
				// 如果当前下表位置的key为null，则说明是被gc回收的
                if (k == null)
                	// 清理过期的Entry
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }
    }
}

public class ThreadLocal {
	// set方法
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            // 以当前ThreadLoca对象作为key
            map.set(this, value);
        else
            createMap(t, value);
    }
    // 获取 当前线程 Thread 里的ThreadLocal.ThreadLocalMap 属性
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
    // ThreadLocalMap 的set方法
    static class ThreadLocalMap {
        private void set(ThreadLocal key, Object value) {

            Entry[] tab = table;
            int len = tab.length;
            // 通过hash计算数组下标
            int i = key.threadLocalHashCode & (len-1);
			// 从该下标向后遍历
            for (Entry e = tab[i];
                 e != null;  // 如果该处Entry 不为null
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal k = e.get();
				// 找到当前key，更新value
                if (k == key) {
                    e.value = value;
                    return;
                }
                // 如果当前key为null（被gc回收），则进行覆盖。
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
			// 放进 ThreadLocalMap 的元素里
            tab[i] = new Entry(key, value);
            int sz = ++size;
            // 清理空槽
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
            	// 如果没有清理掉，且已达到阈值，则进行扩充
                rehash();
        }
        // Entry 继承弱引用类
        static class Entry extends WeakReference> {
            Object value;
			// 将ThreadLoca 转为弱引用
            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }
    }
}

为什么会被设置为弱引用

ThreadLocal是在ThreadLocalMap.Entry里被设置为弱引用的key，如果是强引用的话，当线程一直执行下去，且已没有外部强引用指向ThreadLocal,那么该 ThreadLocal 就无法被回收，导致内存泄露。

内存泄露问题

ThreadLocal 在ThreadLocal.ThreadLocalMap.Entry里作为key，且被设置为弱引用，所以当没有强引用指向时，就会被gc回收。
如果线程一直执行下去，那么在ThreadLocal.ThreadLocalMap.Entry里的强引用 value 就无法被回收。就会导致内存泄露。

设计者在很多地方都做了清理无用Entry，即key被回收的Entry。比如通过 key 查找 Entry 的时候，如果下标无法直接命中，那么就会向后遍历数组，此时遇到 key 为 null 的 Entry 就会清理掉；扩容时也会进行清理操作；set时，如果key为null，也会进行覆盖操作等。
这些被动的回收操作并不是做好的方法。最佳的实践方法是及时调用threadLocal.remove()方法进行清理。

当ThreadLocal 遇上线程池

线程池里的线程在执行完之后不会被销毁。
当线程再次被使用时，从ThreadLocal里获取的value可能是该线程上次被使用时创建使用的。所以可能会导致数据错误。
因为线程不被销毁，因此也会导致value内存泄露。

解决方案：当线程执行完成时，及时调用threadLocal.remove()方法来清除本次产生的value。

注：上述内存泄露的前提均是线程一直执行下去。当线程执行完，该线程的所有属性都会被回收。