简介

ThreadLocal 作用就像它的名字一样，通过 ThreadLocal 将传入的对象变成线程私有化的对象，即传入的对象只对传入它的线程可见。

在看 Android 的消息机制的时候，在 Looper 类的中的 prepare() 方法中看到了 ThreadLocal 的使用。

    public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

这里的 sThreadLocal.set(new Looper(quitAllowed)) 便是使用了 ThreadLocal 的 set() 方法传入了一个 Looper 对象。

我们也从这里看一下 ThreadLoacl 实现的原理。

ThreadLoacl 的 set() 方法

    public void set(T value) {
        //获取当前线程
        Thread t = Thread.currentThread();
        //获取当前线程的 ThreadLocalMap 
        ThreadLocalMap map = getMap(t);
        //如果 map 不为 null，那么将对象存入
        if (map != null)
            map.set(this, value);
        //否则创建一个新的 ThreadLocalMap    
        else
            createMap(t, value);
    }

这一部分的源码还是很简单，首先获取当前线程，再去获取当前线程的 ThreadLocalMap，最后将我们传入的对象存放在 ThreadLocalMap 中。

这里去 getMap() 方法中看下 ThreadLocalMap 是个怎么样的数据结构。

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

可以看到这里返回了 Thread 中的 threadLocals 字段，说明了 ThreadLocal 只是一个帮助我们实现线程对象私有化的工具，具体私有化的对象还是存放在 Thread 自身的。

再看下 createMap() 方法

    void createMap(Thread t, T firstValue) {
        //  这里就是为 Thread 创建一个 ThreadLocalMap
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

这里我们对 set() 方法的流程有了一个清晰的认知，接下来去看一下 ThreadLocalMap。

ThreadLocalMap

这里看下 ThreadLocalMap 的结构。

ThreadLocalMap 中的弱引用

    static class ThreadLocalMap {

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

这里可以看见 ThreadLocalMap 中的 Entry 是继承弱引用的，所以当线程回收的时候，ThreadLocalMap 不会因为持有对象引用而导致线程无法回收。

构造方法

        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            //INITIAL_CAPACITY 的值是 16    
            table = new Entry[INITIAL_CAPACITY];
            //计算 hashcode 来确定其在数组中的位置
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            //设置阈值，超过就扩容，阈值为容积的 2/3
            setThreshold(INITIAL_CAPACITY);
        }

接下来直接去看下 set() 方法中用到过的 ThreadLocalMap 的 set() 方法，来对 ThreadLocalMap 做个基本的了解。

ThreadLocalMap 的 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.
    //获取 table
    Entry[] tab = table;
    int len = tab.length;
    //计算索引
    int i = key.threadLocalHashCode & (len-1);
    //这里是为了找到已经存在的 Entry，对其中已经存在的值进行替换, 其中 nextIndex() 方法就是对 i+1 取 len 的余 
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();
        //如果存在，则替换 value
        if (k == key) {
            e.value = value;
            return;
        }
        //如果 Entry 过期，那么全部替换（线程回收之类的会过期）
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    //如果没有重复 key 的 Entry， 那么添加新的 Entry 到数组中
    tab[i] = new Entry(key, value);
    int sz = ++size;
    //如果超出阈值，那么扩容
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

这里就不介绍扩容了，对 ThredHashMap 做一个大致的了解即可，其实它的原理还是和 HashMap 非常像的。

ThreadLocal 的 get() 方法

看完上面的 set 的流程其实已经对 ThreadLocal 有一定的了解了，接下来我们看下他的 get() 方法。

    public T get() {
        //同样是获取当线程并且获取它的 ThreadLocalMap    
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            //如果map不为空，尝试获取它的 Entry 对象
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                //如果 entry 不为空，返回私有化的对象
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        //以上条件不符合，则返回初始值
        return setInitialValue();
    }

继续看 setInitialValue() 方法

    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;
    }
    
    protected T initialValue() {
        return null;
    }

这里可以看到，它会通过 initialValue() 方法直接返回 null 值，同时再尝试去获取一下 map 是否存在，不存在的话就创建一个 map，反之将值存入map,最后会返回 null 值。

总结

ThredLocal 的介绍就到这里了，这里对它做个总结。

• 每个 Thread 都存有一个 ThreadLocalMap
• ThreadLocal 本身不缓存任何值，是对 Thread 中的 ThreadLocalMap 进行操作。
• ThreadLocalMap 与 HashMap 十分相似，但是是一个纯数组的实现的 Map, 它以线程做为键值，同时每个线程只能缓存一个对象。
• ThreadLocalMap 的初始容量 为 16， 阈值为容量的 2/3，超出阈值会触发扩容， 扩容为原来的两倍。
• ThreadLocalMap 遇到哈希碰撞时，是将索引向后移动一位处理。
• ThreadLocal set 和 get 都是以当前线程为键值获取 ThreadLocal Map 中的对象，以此实现线程对象的私有化。

最后回到前面我遇到 ThreadLocal 的地方

    public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

这里就是将 Looper 对象传入 ThreadLocal，保证 Looper 只对当前线程可见，避免并发危险。