ThreadLocal 源码详细解析

ThreadLocal 源码详细解析

写这篇文章不在计划之内， 主要是分析到Handler消息机制一文中，牵涉到ThreadLocal内容，一次全部写完文章过长，所以打算单独摘出来梳理成为一篇文章。

引言

在我们日常开发中用到ThreadLocal的地方很多，在JDK 1.2的版本中就提供java.lang.ThreadLocal，ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序，ThreadLocal并不是一个Thread，而是Thread的局部变量。

核心部分

这里最主要的部分就是ThreaLcoal内部维护了一个HashMap， 下边我们看一下最主要的类ThreadLocalMap

ThreadLocal类

• 每个线程有一个自己的 ThreadLocalMap 对象
• 每一个 ThreadLocal 对象有一个创建时生成唯一的 Id
• 访问一个 ThreadLocal 变量的值，就是用这个唯一 Id 去本线程的 ThreadLocalMap 中查找对应的值

set方法

重点 敲黑板 来一起看源码。

   /**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        /// 可以看到在ThreadLocal创建的时候， 是获取到了当前线程t， 然后获取线程t的本地存储ThreadLcoalMap,然后对map进行操作。
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
        /// 当然如果当前线程还没有创建过ThreadLocalMap，则创建Map
            createMap(t, value); /// 创建Map 的过程 看下边ThreadLocalMap 中方法。
    }

get方法

接下来看一下另一个重要方法，get方法

    /**
     * Returns the value in the current thread's copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread's value of this thread-local
     */
    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        /// 同样是获取到了线程内部的引用 map对象， 通过map内部getEntry方法 获取到该ThreadLocal对应的对象Entry 
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        // 如果没有， 默认为null， 所以在没有set 而且没有重写initialValue方法的话，获取到的值就是null。
        return setInitialValue();
    }

    /**
     * Variant of set() to establish initialValue. Used instead
     * of set() in case user has overridden the set() method.
     *
     * @return the initial value
     */
    private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            /// 如果还没有该map ，则使用当前初始值来创建。默认为null
            createMap(t, value);
        return value;
    }

     /**
     * 返回为当前线程创建的初始化值使用， 一般在get方法中调用和 remove方法后get调用， 
     * 如果使用可以通过内部类继承然后重写该方法即可。
     *
     * @return the initial value for this thread-local
     */
    protected T initialValue() {
        return null;
    }

    /**
     * Get the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     * 获取到Thread的内部引用对象 threadLcoals
     * @param  t the current thread
     * @return the map
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

remove 方法

 /**
     * Removes the current thread's value for this thread-local
     * variable.  If this thread-local variable is subsequently
     * {@linkplain #get read} by the current thread, its value will be
     * reinitialized by invoking its {@link #initialValue} method,
     * unless its value is {@linkplain #set set} by the current thread
     * in the interim.  This may result in multiple invocations of the
     * {@code initialValue} method in the current thread.
     *
     * @since 1.5
     */
     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
            /// 这个方法就是通过map 的内部方法 remove 移除当前的值。 
             m.remove(this);
     }

ThreadLocal与Thread关系

说起ThreadLocal 与Thread的关系，借用Java编程思想中对线程本地存储的定义， 防止任务在共享资源上产生冲突的第二种方式是根除对变量的共享。线程本地存储是一种自动化机制，可以为使用相同变量的每个不同的线程都创建不同的存储。 简单理解一下就是Thread上的LocalVariables了， 既然如此就进入Thread源码看一下。 很明显就找到了相关引用。

    /* Thread中引用了 ThreadLocal.ThreadLocalMap  很明显一线程中可以放置很多变量 , 这个Map可以在ThreadLocal中维护  */
    ThreadLocal.ThreadLocalMap threadLocals = null;

    /*
     * InheritableThreadLocal 可继承的ThreadLcoal
     这个Map可以在ThreadLocal中维护
     */
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

主要用于在创建线程时继承当前线程的ThreadLocal values ， 可以在Thread 的init中调用， 一般情况下，如果父类的可继承的ThreadLcoal.ThreadLcoalMap 指定过，并且不为空 则默认创建的子线程继承该变量。 具体创建方法就是ThreadLocal中的createInheritedMap方法。

  if (parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

看一下ThreadLcoal中的createInheritedMap

   /**
     * Factory method to create map of inherited thread locals.
     * Designed to be called only from Thread constructor.
     *
     * 仅仅只有在Thread 构造函数中调用
     * @param  parentMap the map associated with parent thread
     * @return a map containing the parent's inheritable bindings
     */
    static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
        return new ThreadLocalMap(parentMap);
    }

ThreadLocalMap

ThreadLocalMap 是ThreadLocal 的内部类， 既然起名为Map 则肯定和Map有相似之处，下边从get ，set ，remove方法来看。

基本结构

这是ThreadLcoalMap 的基本结构， 继承自弱引用WeakReference 使用了泛型ThreadLcoal

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

create 方法

这里几个方法是创建Map的过程， 列举出调用和最简单的一个构造函数。

    /**
     * Create the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

    /**
     * Construct a new map initially containing (firstKey, firstValue).
     * ThreadLocalMaps are constructed lazily, so we only create
     * one when we have at least one entry to put in it.
     */
    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        /// 创建一个线性table ， Entry 为item ，初始化INITIAL_CAPACITY 默认为16个
        table = new Entry[INITIAL_CAPACITY];
        /// 计算出第一个key的索引 i
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        /// 初始化 并设置size 值
        table[i] = new Entry(firstKey, firstValue);
        size = 1;
        /// 同时 设置容器大小的临界值，并传入初始化大小。
        setThreshold(INITIAL_CAPACITY);
    }

get 方法

    /**
     * Get the entry associated with key.  This method
     * itself handles only the fast path: a direct hit of existing
     * key. It otherwise relays to getEntryAfterMiss.  This is
     * designed to maximize performance for direct hits, in part
     * by making this method readily inlinable.
     * /// 通过Key的hash值来创建其对应的索引值，找到entry 
     *
     * @param  key the thread local object
     * @return the entry associated with key, or null if no such
     */
    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
            /// 如果没有在直接的table线性表中找到的话。
            return getEntryAfterMiss(key, i, e);
    }

可以看出它考虑到了哈希碰撞的情况,因为在遍历set值的时候考虑到哈希碰撞的问题一个节点对应两个值，一般会取(key的hashcode值&table.lenth-1)获取一个数组的位置，将其放入到该节点的位置。这里相当是一个逆运算，省去了遍历的性能开销问题，直接取该节点上的值(可以参考我以前的文章HashMap原理解析)。当然还有getEntryAfterMiss方法是为了解决出现了hash碰撞的问题，以下是getEntryAfterMiss方法：

    /**
     * Version of getEntry method for use when key is not found in
     * its direct hash slot.
     *
     * @param  key the thread local object
     * @param  i the table index for key's hash code
     * @param  e the entry at table[i]
     * @return the entry associated with key, or null if no such
     */
    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;
                /// 如果k为空的直接从链表中擦除，方便GC进行回收
            if (k == null)
                expungeStaleEntry(i);
            else
            /// 循环找到下一个index
                i = nextIndex(i, len);
            e = tab[i];
        }
        return null;
    }

set方法

    /**
     * Set the value associated with key.
     *
     * @param key the thread local object
     * @param value the value to be 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;
        int i = key.threadLocalHashCode & (len-1);

        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;
            }
        }

        tab[i] = new Entry(key, value);
        int sz = ++size;
          //如果数组中没有冗余的null值并且如果size大于临界值
        if (!cleanSomeSlots(i, sz) && sz >= threshold)
            /// 进行扩容 ，这里就不再进行解释如何扩容了。
            rehash();
    }

remove

    /**
     * Remove the entry for key.
     */
    private void remove(ThreadLocal<?> key) {
        Entry[] tab = table;
        int len = tab.length;
        int i = key.threadLocalHashCode & (len-1);
        for (Entry e = tab[i];
             e != null;
             e = tab[i = nextIndex(i, len)]) {
            if (e.get() == key) {
                e.clear();
                // 置空，以便GC回收
                expungeStaleEntry(i);
                return;
            }
        }
    }

散列

理解了上边所说的ThreadLocalMap 的引用以及get和set， 这里就引出了个问题，如何保证每个线程中引用ThreadLcoalMap中创建的ThreadLcoal是唯一，并且高效的存取就成了至关重要的问题。
看到上边的ThreadLcoalMap中的set方法 和get方法， 如果懂得HashMap存储结构的话， 会发现和HashMap中indexfor (key的Hash& table.length-1) 有的一拼， 但是这里用的Hash key生成器不是ThreadLcoal对象的Hash值， 而是从0开始的AtomicInteger 通过getAndAdd HASH_INCREMENT 来生成。

   /**
     * The next hash code to be given out. Updated atomically. Starts at
     * zero.
     */
    private static AtomicInteger nextHashCode =
        new AtomicInteger();

    /**
     * The difference between successively generated hash codes - turns
     * implicit sequential thread-local IDs into near-optimally spread
     * multiplicative hash values for power-of-two-sized tables.
     */
    private static final int HASH_INCREMENT = 0x61c88647;

    /**
     * Returns the next hash code.
     */
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

这样就保证了每一个 ThreadLocal 对象有一个创建时生成唯一的 Id。

• 为什么要引用这个0x61c88647奇奇怪怪的数字呢？ 这个我也不知道，看注释就是为了让 hash code 能更好地分布在尺寸为 2 的 N 次方的数组里。 随后又网上搜了一下，有篇文章有点解释大概就是 表示的是黄金比例什么的，能够是生成的hashCode更加均匀的分布在2的N次方的数组里。 （英文二把刀见谅）
  如果有哪位数学高人，希望不吝赐教。
  这里放下这篇文章的链接https://www.javaspecialists.eu/archive/Issue164.html

总结

看了这么多，ThreadLcoal结构终于清晰了。 可以这么理解，ThreadLcoal是Thread中持有的一个放置Thread独有变量的Hash表。这个Hash表又经过特殊散列优化，使实用效率更加高效。可以说Java工程师们为了提高程序的结构性和高效性操碎了心啊，对于我们普通使用者来说简单方便而且又浑然一体，的确牛气。