线程的ThreadLocal详解

概述及存储结构

学习参考敖丙ThreadLocal文章
ThreadLocal 不是线程，更不是本地线程，而是 Thread 的局部变量；ThreadLocal 是每个线程独享的本地变量，每个线程都有自己的 ThreadLocal，它们是线程隔离的。

上图中基本描述出了 Thread，ThreadLocalMap 以及 ThreadLocal 三者之间的包含关系。

Thread 类对象中维护了 ThreadLocalMap 成员变量，而 ThreadLocalMap 维护了以 ThreadLocal 为 key，需要存储的数据为 value 的 Entry 数组。

查看 Thread 类，内部维护了两个变量，threadLocals 和 inheritableThreadLocals，它们的默认值是 null，它们的类型是 ThreadLocal.ThreadLocalMap，也就是 ThreadLocal 类的一个静态内部类 ThreadLocalMap。

在静态内部类 ThreadLocalMap 维护一个数据结构类型为 Entry 的数组，节点类型如下代码所示：

	static class ThreadLocalMap {
        //继承弱引用 WeakReference 类
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
    //...
}

Entry 结构实际上是继承了一个 ThreadLocal 类型的弱引用并将其作为 key，value 为 Object 类型；暂且可以理解 key 就是 ThreadLocal 对象；对于 ThreadLocalMap，我们一起来了解一下其内部的变量：

		//默认数组的初始容量 16
        private static final int INITIAL_CAPACITY = 16;
		//Entry 数组，大小是 2 的幂
        private Entry[] table;
		//数组内元素的个数
        private int size = 0;
		//数组扩容阈值，默认为 0，创建了 ThreadLocalMap 对象后会被重新设置
        private int threshold; // Default to 0

这几个变量和 HashMap 中的变量十分类似，功能也类似。

ThreadLocalMap 的构造方法：

	ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        	//初始化数组大小为 16
            table = new Entry[INITIAL_CAPACITY];
        	//用第一个键的哈希值对初始大小取模得到索引，和 HashMap 的位运算代替取模原理一样
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        	//将 Entry 对象存入数组指定位置
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
        	//初始化扩容阈值，第一次设置为 10：threshold = len * 2 / 3
            setThreshold(INITIAL_CAPACITY);
        }

从构造方法的注释中可以了解到，该构造方法是懒加载的，只有当我们创建一个 Entry 对象并需要放入到 Entry 数组的时候才会去初始化 Entry 数组。

分析到这里，也许我们都有一个疑问，平常使用 ThreadLocal 功能都是借助 ThreadLocal 对象来操作的，比如 set，get，remove 等，使用上都屏蔽了 ThreadLocalMap 的 API，那么到底是如何做到的呢？

---

set 方法

试想我们一个请求对应一个线程，我们可能需要在请求到达拦截器之后，可能需要校验当前请求的用户信息，那么校验通过的用户信息通常都放入到 ThreadLocalMap 中，以方便在后续的方法中直接从 ThreadLocalMap 中获取。

但是我们都是通过一个静态的 ThreadLocal 变量来操作，从上面的图可以看出，ThreadLocalMap 中存储的键其实就是 ThreadLocal 的弱引用所关联的对象；那么就先看以下 set 方法：

	public void set(T value) {
        // 首先获取调用此方法的线程
        Thread t = Thread.currentThread();
        // 将线程传递到 getMap 方法中来获取 ThreadLocalMap
        //其实就是获取到当前线程的成员变量 threadLocals 所指向的 ThreadLocalMap 对象
        ThreadLocalMap map = getMap(t);
        // 判断 map 是否为空
        if (map != null)
        // 如果Map为不空，说明当前线程内部已经有ThreadLocalMap对象了
       	//那么直接将本ThreadLocal对象作为键，存入的value作为值存储到ThreadLocalMap中
            map.set(this, value);
        else
       	//否则创建一个ThreadLocalMap对象并将值存入到该对象中
        //并赋值给当前线程的threadLocals成员变量
            createMap(t, value);
    }

	ThreadLocalMap getMap(Thread t) {
        //获取当前线程的 ThreadLocalMap 对象 threadLocals
        return t.threadLocals;
    }

	void createMap(Thread t, T firstValue) {
        //如果没有，就创建一个 ThreadLocalMap 对象
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

上面的 set 方法是 ThreadLocal 的 set 方法，就是为了将指定的值存入到指定线程的 threadLocals 成员变量所指向的 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.
    Entry[] tab = table;
    int len = tab.length;
    // 计算当前ThreadLocal对象作为键在Entry数组中的下标索引
    int i = key.threadLocalHashCode & (len-1);
	// 线性遍历，首先获取到指定下标的Entry对象，如果不为空，则进入到for循环体内，
    // 判断当前的ThreadLocal对象是否是同一个对象，如果是，那么直接进行值替换，并结束方法，
    // 如果不是，再判断当前Entry的key是否失效，如果失效，则直接将失效的key和值进行替换。
    // 这两点都不满足的话，那么就调用nextIndex方法进行搜寻下一个合适的位置，进行同样的操作，
    // 直到找到某个位置，内部数据为空，也就是Entry为null，那么就直接将键值对设置到这个位置上。
    // 最后判断是否达到了扩容的条件，如果达到了，那么就进行扩容。
    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;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

这里有两点需要注意：一是 nextIndex 方法，二是 key 失效，这里先解释第一个注意点，第二个注意点涉及到弱引用JVM GC 问题，文章最后做出解释；

nextIndex 方法：

其实就是寻找下一个合适位置，找到最后一个后还不合适的话，那么从数组头部重新开始找，且一定可以找到，因为存在扩容阈值，数组必定有冗余的位置存放当前键值对所对应的 Entry 对象。其实 nextIndex 方法就是大名鼎鼎的开放寻址法的应用。

private static int nextIndex(int i, int len) {
	 return ((i + 1 < len) ? i + 1 : 0);
}                                        

---

get 方法

在实际的开发中，我们往往需要在代码中调用 ThreadLocal 对象的 get 方法来获取存储在 ThreadLocalMap 中的数据，具体的源码如下所示：

	public T get() {
        Thread t = Thread.currentThread();
		// 获取当前线程的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        if (map != null) {
             //如果map不为空，那么尝试获取Entry数组中以当前ThreadLocal对象为键的Entry对象
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                 // 如果找到，那么直接返回value
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
 	// 如果Map为空或者在Entry数组中没有找到以当前ThreadLocal对象为键的Entry对象，
    // 那么就在这里进行值初始化，值初始化的过程是将null作为值，当前ThreadLocal对象作为键，
    // 存入到当前线程的ThreadLocalMap对象中
        return 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;
}

值初始化过程是这样的一个过程，如果调用新的 ThreadLocal 对象的 get 方法，那么在当前线程的成员变量 threadLocals 中必定不存在 key 为当前 ThreadLocal 对象的 Entry 对象，那么这里值初始话就将此 ThreadLocal 对象作为 key，null 作为值存储到 ThreadLocalMap 的 Entry 数组中。

---

remove 方法

     public void remove() {
         //获取ThreadLocalMap对象
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }
	// 具体的删除指定的值，也是通过遍历寻找，找到就删除，找不到就算了
	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();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }

理解 ThreadLocal 原理，其实就是需要理清 Thread，ThreadLocal，ThreadLocalMap 三者之间的关系。

小结：

线程类 Thread 内部持有 ThreadLocalMap 的成员变量，而 ThreadLocalMap 是 ThreadLocal 的内部类，ThreadLocal 操作了 ThreadLocalMap 对象内部的数据，对外暴露的都是 ThreadLocal 的方法 API，隐藏了 ThreadLocalMap 的具体实现。

---

内存泄漏问题

在学习完 JVM 后我们都会知道，引用一般分为强，软，弱，虚，那么先稍微回顾以下这四种引用：

• 强引用（Strong Reference）：最传统的“引用”的定义，是指在程序代码之中普遍存在的引用赋值，即类似 “Object obj=new object( )” 这种引用关系；无论任何情况下，只要强引用关系还存在，垃圾收集器就永远不会回收掉被引用的对象；

• 软引用（Soft Reference）：在系统将要发生内存溢出之前，将会把这些对象列入回收范围之中进行第二次回收。如果这次回收后还没有足够的内存，才会抛出内存溢出异常；

• 弱引用（WeakReference）：被弱引用关联的对象只能生存到下一次垃圾收集之前。当垃圾收集器工作时，无论内存空间是否足够，都会回收掉被弱引用关联的对象；

• 虚引用（PhantomReference）：一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来获得一个对象的实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知；

---

并且之前也说过 ThreadLocalMap 中其实是维护了一个 Entry 对象，而该对象也正是继承了 WeakReference，并且 ThreadLocal 的引用 k 通过构造方法传递给了 Entry 类的父类 WeakReference 的构造方法（super(k)）;

当一个线程调用 ThreadLocal 的 set 方法设置变量的时候，当前线程的 ThreadLocalMap 就会存放一个记录，这个记录的键为 ThreadLocal 的弱引用，value 就是通过 set 设置的值，这个 value 值被强引用。

如果当前线程还存在，由于线程的 ThreadLocalMap 里面的 key 是弱引用，所以当前线程的 ThreadLocalMap 里面的 ThreadLocal 变量的弱引用在垃圾回收的时候就被回收，但是对应的 value 还是存在的这就可能造成内存泄漏（这个时候 ThreadLocalMap 会存在 key 为 null 但是 value 不为 null 的 entry 项）。

---

总结

在每个 Thread 类中维护了一个 ThreadLocalMap 对象，而 ThreadLocalMap 是 ThreadLocal 中的一个静态内部类，并且其中也是维护了一个 Entry 类，并且该类继承了 WeakReference 弱引用类，因此在存储时，Entry 数组中的每个节点的 key 都是一个 ThreadLocal 对象的弱引用，而它的 value 值却是一个强引用，因此每次在添加或者获取的时候也会去判断 key 的值是否有效（是否为 null），因此我们需要注意 ThreadLocal 中的内存泄漏问题。