ThreadLocal

查看了ThreadLocal的源码，TheadLocal的核心是

1. get()
2. set()
3. 静态内部类ThreadLocalMap

理解了这3个部分，就理解了ThreadLocal的工作原理了。

get()

源码如下（android7.0）

    public T get() {
        Thread t = Thread.currentThread();
        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();
    }

其中 getMap()的源码如下

ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

每个线程都有一个自己独有的 ThreadLocalMap 成员变量，任意一个 ThreadLocal对象，只能取出自身为key的在ThreadLocalMap中的数据。也就是说，每一个ThreadLocal.get() 或者set()只能操作当前所在线程的，以该ThreadLocal为key的数据。

set()

源码如下

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

createMap()源码如下

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

set()就是将ThreadLocal作为key，往当前的Thread的ThreadLocalMap插入一条数据

ThreadLocalMap

ThreadLocalMap实际上，作用和一般的map没什么区别，就是内部的实现不一样。ThreadLocalMap内部是使用hash表来存储数据的。

Entry

实际上是一个key-value的结构体，采用弱引用是为了让jvm可以顺利回收内存（在内存不足时），key是一个ThreadLocal

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

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

如果Entry.get()==null时，说明该Entry无效了（被回收）

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;
            // 因为len 是2的n次方，所以i的值是 [0,len-1]
            // 等价于 key.threadLocalHashCode % len, 不过位运算更高效
            int i = key.threadLocalHashCode & (len-1);

            // 从i开始，一直往后查询，替换（如果key相等）
            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;
                }
            }

            // 找到null的槽时，需要新建一个Entry插入相应的位置
            tab[i] = new Entry(key, value);
            int sz = ++size;
            // 没新建一个Entry，都要检查数量是否超过临界值，如果超过，给hash表划分更多的空间
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

getEntry

相对简单，主要依靠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
                // 直接散列到的位置没找到，那么顺着hash表递增（循环）地往下找
                return getEntryAfterMiss(key, i, e);
        }

getEntryAfterMiss

从i开始，一直往下找，直到出现空的槽为止。

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)
                    // 删除被jvm回收的对象
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }

Android7.0的ThreadLocal和6.0的实现是不一样的，不过原理是差不多的，每个线程都有一个自己独有的数据成员，该成员是一个map数据结构，map的内部是通过hash表实现数据的存和取，存取的数据都是以ThreadLocal作为key的。

6.0的代码晦涩难懂，7.0的代码比较容易看懂，估计这就是google修改TheadLocal的实现的原因吧！