ThreadLocal原理与应用详解（2）

2.ThreadLocal实现原理

本文分析源代码基于Android6.0。
代码路径：
libcore/luni/src/main/java/java/lang/ThreadLocal.java
libcore/libart/src/main/java/java/lang/Thread.java

从API官方文档看，ThreadLocal提供了这样一些接口：
public:set()/get()/remove()
protected:initialValue()
从这几个API入手看一下ThreadLocal源代码。

ThreadLocal.java:

    /**
     * Sets the value of this variable for the current thread. If set to
     * {@code null}, the value will be set to null and the underlying entry will
     * still be present.
     *
     * @param value the new value of the variable for the caller thread.
     */
    public void set(T value) {
        Thread currentThread = Thread.currentThread();
        Values values = values(currentThread);
        if (values == null) {
            values = initializeValues(currentThread);
        }
        values.put(this, value);
    }

    /**
     * Returns the value of this variable for the current thread. If an entry
     * doesn't yet exist for this variable on this thread, this method will
     * create an entry, populating the value with the result of
     * {@link #initialValue()}.
     *
     * @return the current value of the variable for the calling thread.
     */
    @SuppressWarnings("unchecked")
    public T get() {
        // Optimized for the fast path.
        Thread currentThread = Thread.currentThread();
        Values values = values(currentThread);
        if (values != null) {
            Object[] table = values.table;
            int index = hash & values.mask;
            if (this.reference == table[index]) {
                return (T) table[index + 1];
            }
        } else {
            values = initializeValues(currentThread);
        }

        return (T) values.getAfterMiss(this);
    }

    /**
     * Removes the entry for this variable in the current thread. If this call
     * is followed by a {@link #get()} before a {@link #set},
     * {@code #get()} will call {@link #initialValue()} and create a new
     * entry with the resulting value.
     *
     * @since 1.5
     */
    public void remove() {
        Thread currentThread = Thread.currentThread();
        Values values = values(currentThread);
        if (values != null) {
            values.remove(this);
        }
    }

梳理一下整个逻辑：
set()/get()/remove()，从当前线程拿到其Values成员变量。Values是定义在ThreadLocal内部的一个包级可见的内部类，是一个类似Map的数据结构，实现从ThreadLocal（作为Key）到Object（作为Value）的映射。在Thread中，只定义了这样一个包级可见的成员变量，没有任何的维护逻辑，维护逻辑都在ThreadLocal中。
上面是大概框架，下面从一些点来仔细研究其实现机制。

2.1ThreadLocal对于Thread.localValues的维护

ThreadLocal得到当前线程的Values方法如下：

    /**
     * Gets Values instance for this thread and variable type.
     */
    Values values(Thread current) {
        return current.localValues;
    }

Thread.java:

    /**
     * Normal thread local values.
     */
    ThreadLocal.Values localValues;

在Thread中，只定义了这样一个包级可见的成员变量，没有任何的维护逻辑，维护逻辑都在ThreadLocal中。

（1）初始化
values()方法获取到localValues的引用，如果发现尚为null，通过initializeValues()初始化

    /**
     * Creates Values instance for this thread and variable type.
     */
    Values initializeValues(Thread current) {
        return current.localValues = new Values();
    }

接下来看看Values类的构造方法

        /**
         * Constructs a new, empty instance.
         */
        Values() {
            initializeTable(INITIAL_SIZE);
            this.size = 0;
            this.tombstones = 0;
        }

        /**
         * Used for InheritableThreadLocals.
         */
        Values(Values fromParent) {
            this.table = fromParent.table.clone();
            this.mask = fromParent.mask;
            this.size = fromParent.size;
            this.tombstones = fromParent.tombstones;
            this.maximumLoad = fromParent.maximumLoad;
            this.clean = fromParent.clean;
            inheritValues(fromParent);
        }

前者比较简单。后者是从一个Parent Values对象创建一个新的Values对象，应用于InheritableThreadLocal。继承稍后介绍。

（2）继承
InheritableThreadLocal是ThreadLocal的一个子类，这里不扩展介绍。继续看看Values的inheritValues()方法

        /**
         * Inherits values from a parent thread.
         */
        @SuppressWarnings({"unchecked"})
        private void inheritValues(Values fromParent) {
            // Transfer values from parent to child thread.
            Object[] table = this.table;
            for (int i = table.length - 2; i >= 0; i -= 2) {
                Object k = table[i];

                if (k == null || k == TOMBSTONE) {
                    // Skip this entry.
                    continue;
                }

                // The table can only contain null, tombstones and references.
                Reference<InheritableThreadLocal<?>> reference
                        = (Reference<InheritableThreadLocal<?>>) k;
                // Raw type enables us to pass in an Object below.
                InheritableThreadLocal key = reference.get();
                if (key != null) {
                    // Replace value with filtered value.
                    // We should just let exceptions bubble out and tank
                    // the thread creation
                    table[i + 1] = key.childValue(fromParent.table[i + 1]);
                } else {
                    // The key was reclaimed.
                    table[i] = TOMBSTONE;
                    table[i + 1] = null;
                    fromParent.table[i] = TOMBSTONE;
                    fromParent.table[i + 1] = null;

                    tombstones++;
                    fromParent.tombstones++;

                    size--;
                    fromParent.size--;
                }
            }
        }

这个方法的作用即从父Thread继承线程本地变量值。