ThreadLocal 源码解析

ThreadLocal为每一个线程提供独立的变量副本，即每个线程都有自己的、独立初始化的变量副本。

public class ThreadLocal<T>

只有一个空的构造器，里面什么也没做

public ThreadLocal() {
}

看看它的重要方法 get() ，其中最重要的ThreadLocalMap稍后会讲

public T get() {
		//当前线程
        Thread t = Thread.currentThread();
        //获取当前线程的ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        if (map != null) {
        //获取map中的值并返回
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        //如果该变量对于当前线程没有值，则首先将其初始化为调用initialValue方法返回的值。
        return setInitialValue();
    }

对于没有赋予值的变量，默认会返回null

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;
    }
    //返回此线程局部变量的当前线程的“初始值”。 
    //该方法将在线程第一次使用get方法访问变量时被调用，
    //除非线程之前调用了set方法，
    //在这种情况下，将不会为线程调用initialValue方法。 
    //通常，每个线程最多调用此方法一次，
    //但在后续调用remove后跟get情况下可能会再次调用它。此实现仅返回null ； 
protected T initialValue() {
        return null;
    }

如果想返回一个初始默认值怎么办？
可以看到源码的解释：
如果程序员希望线程局部变量具有除null之外的初始值，则必须对ThreadLocal进行子类化，并覆盖此方法。 通常，将使用匿名内部类。

set方法

//不多解释，map操作，以threadLocal本身作为key
public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

分析一下ThreadLocal的关键ThreadLocalMap:
这里是ThreadLocal创建ThreadLocalMap的代码：

void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

ThreadLocalMap被定义为静态内部类

static class ThreadLocalMap {

这是它的节点Entry,ThreadLocalMap的静态内部类Entry继承了WeakReference （弱引用）并以此作为键
及时回收可以避免内存泄漏。

弱引用（Weak Reference）：弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存
只具有弱引用：确实没其他用他了

static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }

ThreadLocalMap的成员变量,和HashMap等类似：HashMap解析

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

ThreadLocalMap的构造器

	//通过一个最初包含的值构造
	ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

        /**
         从给定的父映射构造一个包含所有可继承线程本地的新映射。 仅由 createInheritedMap 调用。
         */
        private ThreadLocalMap(ThreadLocalMap parentMap) {
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            setThreshold(len);
            table = new Entry[len];

			//循环，从父复制到新的Map
            for (int j = 0; j < len; j++) {
                Entry e = parentTable[j];
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
                    if (key != null) {
                        Object value = key.childValue(e.value);
                        Entry c = new Entry(key, value);
                        int h = key.threadLocalHashCode & (len - 1);
                        while (table[h] != null)
                            h = nextIndex(h, len);
                        table[h] = c;
                        size++;
                    }
                }
            }
        }

get方法：

//先直接hash后在table数值中获取，若获取不到（hash冲突之后线性探测）用getEntryAfterMiss获取
private Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }
//进入了getEntryAfterMiss方法进行线性探测       
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;

			//循环线性探测
            while (e != null) {
                ThreadLocal<?> k = e.get();
                if (k == key)
                    return e;
                if (k == null)
                	//清理值
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }

expungeStaleEntry（）方法通过重新散列位于 staleSlot 和下一个空槽之间的任何可能冲突的条目来清除陈旧的条目。 这也会清除在尾随空值之前遇到的任何其他陈旧条目。

private int expungeStaleEntry(int staleSlot) {
			//只想table数组
            Entry[] tab = table;
            int len = tab.length;
				
			//先将当前置为空
            // expunge entry at staleSlot
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;


			//重新哈希直到我们遇到 null
            // Rehash until we encounter null
            Entry e;
            int i;
            for (i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();
                //遇到key为null的将槽位也变为null
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                    if (h != i) {
                        tab[i] = null;

                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

resize()函数：扩容为两倍

private void resize() {
            Entry[] oldTab = table;
            int oldLen = oldTab.length;
            int newLen = oldLen * 2;
            Entry[] newTab = new Entry[newLen];
            int count = 0;

            for (int j = 0; j < oldLen; ++j) {
                Entry e = oldTab[j];
                if (e != null) {
                    ThreadLocal<?> k = e.get();
                    //如果key为空，值也变为null帮助GC
                    if (k == null) {
                        e.value = null; // Help the GC
                    } else {
                        int h = k.threadLocalHashCode & (newLen - 1);
                        while (newTab[h] != null)
                            h = nextIndex(h, newLen);
                        newTab[h] = e;
                        count++;
                    }
                }
            }

            setThreshold(newLen);
            size = count;
            table = newTab;
        }

内存泄漏：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key就会导致内存泄漏（虽然实际会自发清理value)。

使用ThreadLocal的弱引用作为key，如果一个ThreadLocal不存在外部强引用时，Key(ThreadLocal)势必会被GC回收，这样就会导致ThreadLocalMap中key为null， 而value还存在着强引用，只有thead线程退出以后,value的强引用链条才会断掉。

但如果当前线程再迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链：

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

永远无法回收，造成内存泄漏。

建议：尽量避免存储大对象，如果非要存，那么尽量在访问完成后及时调用remove()删除掉。

通过源码可以看到不仅Entry继承了软引用，而且做了许多措施(在get,set，remove方法中都发进行自发清理)自发清理value帮助GC，防范内存泄漏。
我们也应该每次使用完ThreadLocal变量之后，执行remove方法主动防范内存泄漏。