1//设置这个线程局部变量map保存当前线程的副本的值value
 2public void set(T value) {
 3    Thread t = Thread.currentThread();
 4    ThreadLocalMap map = getMap(t);
 5    if (map != null)
 6        map.set(this, value);
 7    else
 8        createMap(t, value);
 9}
10
11//这个返回的就是Thread中一个全局变量ThreadLocalMap类型的对象threadLocals
12ThreadLocalMap getMap(Thread t) {
13    return t.threadLocals;
14}
15
16//创建与 ThreadLocal 关联的映射ThreadLocalMap。
17void createMap(Thread t, T firstValue) {
18    t.threadLocals = new ThreadLocalMap(this, firstValue);
19}

 1//返回当前线程的 this 局部变量map保存的线程副本值
 2//如果没有找到该线程副本，返回线程本地的当前线程值
 3public T get() {
 4    Thread t = Thread.currentThread();
 5    ThreadLocalMap map = getMap(t);
 6    if (map != null) {
 7        ThreadLocalMap.Entry e = map.getEntry(this);
 8        if (e != null) {
 9            @SuppressWarnings("unchecked")
10            T result = (T)e.value;
11            return result;
12        }
13    }
14    return setInitialValue();
15}
16
17//初始化，这个方法会覆写原来的set
18private T setInitialValue() {
19    T value = initialValue();
20    Thread t = Thread.currentThread();
21    ThreadLocalMap map = getMap(t);
22    if (map != null)
23        map.set(this, value);
24    else
25        createMap(t, value);
26    return value;
27}
28
29//每个线程只有一次，跟remove配套使用，可供子类覆写
30protected T initialValue() {
31    return null;
32}

1//移除当前线程的ThreadLocal对象
2public void remove() {
3    ThreadLocalMap m = getMap(Thread.currentThread());
4    if (m != null)
5        m.remove(this);
6}

 1ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
 2    table = new Entry[INITIAL_CAPACITY];
 3    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
 4    table[i] = new Entry(firstKey, firstValue);
 5    size = 1;
 6    setThreshold(INITIAL_CAPACITY);
 7}
 8
 9private void setThreshold(int len) {
10    threshold = len * 2 / 3;
11}

 1//Entry构造两个值，一个为key，ThreadLocal<?>,一个是value
 2//其中key是一个弱引用，只要发生垃圾回收，若这个对象只被弱引用指向，那么就会被回收
 3//其中value是强引用，不会被垃圾回收
 4static class Entry extends WeakReference<ThreadLocal<?>> {
 5    /** The value associated with this ThreadLocal. */
 6    Object value;
 7
 8    Entry(ThreadLocal<?> k, Object v) {
 9        super(k);
10        value = v;
11    }
12}

 1//初始容量，必须为2的幂
 2private static final int INITIAL_CAPACITY = 16;
 3//Entry表，大小必须为2的幂
 4private Entry[] table;
 5//表里entry的个数
 6private int size = 0;
 7//重新分配表大小的阈值，默认为0
 8private int threshold; 
 9
10//环形意义的下一个索引
11private static int nextIndex(int i, int len) {
12    return ((i + 1 < len) ? i + 1 : 0);
13}
14
15//环形意义的上一个索引
16private static int prevIndex(int i, int len) {
17    return ((i - 1 >= 0) ? i - 1 : len - 1);
18}

 1//它在该ThreadLocal被构造的时候就会生成，相当于一个ThreadLocal的ID。这个是哈希散列表的下一个
 2private final int threadLocalHashCode = nextHashCode();
 3private static AtomicInteger nextHashCode =
 4    new AtomicInteger();
 5//ThreadLocal中定义了一个AtomicInteger,一个魔数0x61c88647，利用算法实现了元素的完美散列
 6private static final int HASH_INCREMENT = 0x61c88647;
 7//哈希函数
 8private static int nextHashCode() {
 9    return nextHashCode.getAndAdd(HASH_INCREMENT);
10}

1int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);

 1//传入的值对应table中的Entry为null或者k=null
 2//返回的值对应table中Entry为null
 3private int expungeStaleEntry(int staleSlot) {
 4    Entry[] tab = table;
 5    int len = tab.length;
 6
 7    // 清理过时的插槽，即把部分回收类型变成空类型
 8    tab[staleSlot].value = null;
 9    tab[staleSlot] = null;
10    size--;
11
12    //遇到null的时候会重新hash
13    Entry e;
14    int i;
15    for (i = nextIndex(staleSlot, len);
16         (e = tab[i]) != null;
17         i = nextIndex(i, len)) {
18        ThreadLocal<?> k = e.get();
19        //出现部分回收类型，置为空
20        if (k == null) {
21            e.value = null;
22            tab[i] = null;
23            size--;
24        } else {
25            //k不为null时候，重新hash函数
26            int h = k.threadLocalHashCode & (len - 1);
27            if (h != i) {
28                tab[i] = null;
29
30                //与Knuth 6.4算法R不同，我们必须扫描直到为空，因为多个条目可能已经过时
31                while (tab[h] != null)
32                    h = nextIndex(h, len);
33                tab[h] = e;
34            }
35        }
36    }
37    //出现空类型，直接返回结果空类型的下标
38    return i;
39}

 1//传入的值对应table中的Entry为null或者k!=null
 2//如果在接下来的循环顺序5个Entry中没有找到k=null，则返回false
 3//找到开始探测式清理，并重置循环5个Entry，最终返回true
 4private boolean cleanSomeSlots(int i, int n) {
 5    boolean removed = false;
 6    Entry[] tab = table;
 7    int len = tab.length;
 8    do {
 9        i = nextIndex(i, len);
10        Entry e = tab[i];
11        if (e != null && e.get() == null) {
12            n = len;
13            removed = true;
14            i = expungeStaleEntry(i);
15        }
16    } while ( (n >>>= 1) != 0);
17    return removed;
18}

 1private void set(ThreadLocal<?> key, Object value) {
 2    //set的流程相对来说会比较复杂，往往通过hash下标对应不上
 3    Entry[] tab = table;
 4    int len = tab.length;
 5    int i = key.threadLocalHashCode & (len-1);
 6
 7    for (Entry e = tab[i];
 8         e != null;
 9         e = tab[i = nextIndex(i, len)]) {
10        ThreadLocal<?> k = e.get();
11        //情况2:找不到对应的k,循环下一个查找，直到找到当前的k为key，那么替换value值
12        if (k == key) {
13            e.value = value;
14            return;
15        }
16        //情况4:找不到对应的k,循环下一个查找，直到找到一个部分回收类型
17        if (k == null) {
18            replaceStaleEntry(key, value, i);
19            return;
20        }
21    }
22
23    //情况1:下一个Entry为空类型，构造一个Entry放入，并作启发式清理
24    //情况3:Entry类型一直为全类型，但是k != key，直到遇到空类型，并做启发式清理
25    tab[i] = new Entry(key, value);
26    int sz = ++size;
27    if (!cleanSomeSlots(i, sz) && sz >= threshold)
28        rehash();
29}

 1//set过程中遇到部分回收类型
 2private void replaceStaleEntry(ThreadLocal<?> key, Object value,
 3                               int staleSlot) {
 4    Entry[] tab = table;
 5    int len = tab.length;
 6    Entry e;
 7
 8    //检查是否勋在部分回收类型，避免由于垃圾回收造成这种类型在散列表中持续增加
 9    int slotToExpunge = staleSlot;
10    for (int i = prevIndex(staleSlot, len);
11         (e = tab[i]) != null;
12         i = prevIndex(i, len))
13        if (e.get() == null)
14            slotToExpunge = i;
15
16    //找到全类型和空类型
17    for (int i = nextIndex(staleSlot, len);
18         (e = tab[i]) != null;
19         i = nextIndex(i, len)) {
20        ThreadLocal<?> k = e.get();
21
22        //找到key就交换，使用hash下标来维护哈希表的顺序
23        if (k == key) {
24            e.value = value;
25
26            tab[i] = tab[staleSlot];
27            tab[staleSlot] = e;
28
29            // 开始清理
30            if (slotToExpunge == staleSlot)
31                slotToExpunge = i;
32            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
33            return;
34        }
35        //向后没有找到部分回收类型，那么开始扫描仍是第一个条目
36        if (k == null && slotToExpunge == staleSlot)
37            slotToExpunge = i;
38    }
39
40    // 如果没有找到key，那么新建一个Entry，value为null
41    tab[staleSlot].value = null;
42    tab[staleSlot] = new Entry(key, value);
43    
44    if (slotToExpunge != staleSlot)
45        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
46}

1//当大小大于等于扩容阈值，才有机会扩容
2threshold = len * 2 / 3;
3sz >= threshold
4//探测式清理完成之后，再次比较大小，一半的len    
5size >= threshold - threshold / 4

 1private Entry getEntry(ThreadLocal<?> key) {
 2    int i = key.threadLocalHashCode & (table.length - 1);
 3    Entry e = table[i];
 4    //直接命中
 5    if (e != null && e.get() == key)
 6        return e;
 7    else
 8        //非直接命中
 9        return getEntryAfterMiss(key, i, e);
10}

 1//非直接命中，通过循环依次遍历，看能否找到
 2private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
 3    Entry[] tab = table;
 4    int len = tab.length;
 5
 6    while (e != null) {
 7        ThreadLocal<?> k = e.get();
 8        if (k == key)
 9            return e;
10        if (k == null)
11            expungeStaleEntry(i);
12        else
13            i = nextIndex(i, len);
14        e = tab[i];
15    }
16    return null;
17}

 1private void remove(ThreadLocal<?> key) {
 2    Entry[] tab = table;
 3    int len = tab.length;
 4    int i = key.threadLocalHashCode & (len-1);
 5    for (Entry e = tab[i];
 6         e != null;
 7         e = tab[i = nextIndex(i, len)]) {
 8        if (e.get() == key) {
 9            e.clear();
10            expungeStaleEntry(i);
11            return;
12        }
13    }
14}

 1//frameworks/base/core/java/android/view/Choreographer.java#getInstance
 2public static Choreographer getInstance() {
 3    return sThreadInstance.get();
 4}
 5
 6// Thread local storage for the choreographer.
 7private static final ThreadLocal<Choreographer> sThreadInstance =
 8    new ThreadLocal<Choreographer>() {
 9    @Override
10    protected Choreographer initialValue() {
11        Looper looper = Looper.myLooper();
12        if (looper == null) {
13            throw new IllegalStateException("The current thread must have a looper!");
14        }
15        Choreographer choreographer = new Choreographer(looper, VSYNC_SOURCE_APP);
16        if (looper == Looper.getMainLooper()) {
17            mMainInstance = choreographer;
18        }
19        return choreographer;
20    }
21};

 1//返回当前线程的 this 局部变量map保存的线程副本值
 2//如果没有找到该线程副本，返回线程本地的当前线程值
 3public T get() {
 4    Thread t = Thread.currentThread();
 5    ThreadLocalMap map = getMap(t);
 6    if (map != null) {
 7        ThreadLocalMap.Entry e = map.getEntry(this);
 8        if (e != null) {
 9            @SuppressWarnings("unchecked")
10            T result = (T)e.value;
11            return result;
12        }
13    }
14    return setInitialValue();
15}
16
17//初始化，这个方法会覆写原来的set
18private T setInitialValue() {
19    T value = initialValue();
20    Thread t = Thread.currentThread();
21    ThreadLocalMap map = getMap(t);
22    if (map != null)
23        map.set(this, value);
24    else
25        createMap(t, value);
26    return value;
27}
28
29//每个线程只有一次，跟remove配套使用，可供子类覆写，这里的匿名内部类复写了
30protected T initialValue() {
31    return null;
32}