ThreadLocal底层源码分析

一、常见误解
如果我们不去看源码，可能会猜测ThreadLocal的设计是：每个ThreadLocal都创建一个Map，然后使用线程作为Map的key，要存储的局部变量作为Map的value，这样就可以实现各个线程的局部变量隔离的效果。这是最简单的设计方法，JDK早期的ThreadLocal确实是这样设计，但现在早已经不是。
二、实际实现

但是，JDK后面优化了设计方案，在JDK8中ThreadLocal的设计是：每个Thread维护一个ThreadLocalMap，这个Map的key是ThreadLocal实例本身，value才是真正要存储的值Object。具体过程如下：

1. 每个Thread线程内部都有一个Map(ThreadLocalMap)
2. Map里面存储ThreadLocal对象(key)和线程的变量副本(value)
3. Thread内部的Map是由ThreadLocal维护的，由ThreadLoal负责向map获取和设置线程的变量值。
4. 对于不同线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，互不干扰。
   
   JDK的设计方案两个好处：
   1、每个Map存储的Entry数量变少
   2、当Thread销毁的时候，ThreadLocalMap也会随之销毁，减少内存的使用

三、ThradLocal的核心方法源码
ThreadLocal除了构造方法，向外暴露的方法有以下4个：

set方法
（1）源码与对应中文注释

	/**
	 * 设置当前线程对应的ThreadLocal的值
	 * @param value 将要保存在当前线程对应的ThreadLocal的值
	 *
	 */
	public void set(T value) {
		// 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取此线程对象中维护的ThreadLoalMap对象
        ThreadLocalMap map = getMap(t);
        // 判断map是否存在
        if (map != null)
        	// 存在则调用map.set设置此实体entry(当前ThreadLocal作为key)
            map.set(this, value);
        else
        	// 1) 当前线程Thread不存在ThreadLocalMap对象
        	// 2) 则调用createMap进行ThreadLocalMap的初始化
        	// 3) 并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
            createMap(t, value);
    }


    /**
     * 获取当前线程Thread对应维护的ThreadLocalMap
     *
     * @param  t the current thread 当前线程
     * @return the map	对应维护的ThreadLocalMap
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

	 /**
     * 创建当前线程Thread对应维护的ThreadLocalMap
     *
     * @param t 当前线程
     * @param firstValue 存放map中第一个entry的值
     */
    void createMap(Thread t, T firstValue) {
    	// 这里的this是调用此方法的threadLocal对象
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

（2）代码执行流程
A、首先获取当前线程，并根据当前线程获取一个Map
B、如果获取的Map不为空，则将参数设置到Map中(当前TheadLocal的引用作为key)
C、如果Map为空，则给该线程创建Map，并设置初始值

get方法
（1）源码与对应中文注释

    /**
     * 返回当前线程中保存的ThreadLocal的值
     * 如果当前线程没有此ThreadLocal变量，
     * 则它会通过调用{@link #initialValue} 方法进行初始化值
     *
     * @return 返回当前线程对应此ThreadLocal的值
     */
    public T get() {
    	// 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取此线程对象中维护的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        // 如果此Map存在
        if (map != null) {
        	// 以当前的ThreadLocal 为 key，调用getEntry获取对应的存储实体e
            ThreadLocalMap.Entry e = map.getEntry(this);
            // 对e进行判空
            if (e != null) {
                @SuppressWarnings("unchecked")
                // 获取存储实体 e 对应的 value 值
                // 即为我们想要的当前线程对应此ThreadLocal的值
                T result = (T)e.value;
                return result;
            }
        }
        /**
         * 初始化：有两种情况有执行当前代码
         * 第一种情况：map不存在，表示此线程没有维护的ThreadLocalMap对象
         * 第二种情况：map存在，但是没有与当前ThreadLocal关联的entry
         */
        return setInitialValue();
    }

	/**
     * 初始化
     *
     * @return 初始化后的值
     */
    private T setInitialValue() {
    	// 调用initialValue获取初始化的值
    	// 此方法可以被子类重写，如果不重写默认返回null
        T value = initialValue();
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取此线程对象中维护的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        // 判断map是否存在
        if (map != null)
        	// 存在则调用map.set设置此实体entry
            map.set(this, value);
        else
        	// 1) 当前线程Thread不存在ThreadLocalMap对象
        	// 2) 则调用createMap进行ThreadLocalMap对象的初始化
        	// 3) 并将t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
            createMap(t, value);
        return value;
    }


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

（2）代码执行流程
A、首先获取当前线程，根据当前线程获取一个Map
B、如果获取的Map不为空，则在Map中以ThreadLocal的引用作为key来在Map中获取对应的Entry e，否则转到D
C、如果e不为null，则返回e.value，否则转到D
D、Map为空或者e为空，则通过initialValue函数获取初始值value，然后用ThreadLocal的引用和value作为firstKey和firstValue创建一个新的Map
总结：先获取当前线程的 ThreadLocalMap变量，如果存在则返回值，不存在则创建并返回初始值。

remove()方法
（1）源码与对应中文注释

	/**
     * 删除当前线程中保存的ThreadLocal对应的实体entry
     */
     public void remove() {
     	 // 获取当前线程对象中维护的ThreadLocalMap对象
         ThreadLocalMap m = getMap(Thread.currentThread());
         // 如果此map存在 
         if (m != null)
         	 // 存在则调用map.remove
         	 // 以当前ThreadLocal为key删除对应的实体entry
             m.remove(this);
     }
1
2
3
4
5
6
7
8
9
10
11
12

（2）代码执行流程
A、首先获取当前线程，并根据当前线程获取一个Map
B、如果获取的Map不为空，则移除当前ThreadLocal对象对应的entry

initialValue方法
（1）源码与对应中文注释

	/**
     * 返回当前线程对应的ThreadLocal的初始值
     * 此方法的第一次调用发生在，当线程通过get方法访问此线程的ThreadLocal值时
     * 除非线程先调用了set方法，在这种情况下，initialValue方法才不会被这个线程调用
     * 通常情况下，每个线程最多调用一次这个方法
     * 
     * 这个方法仅仅简单的返回null
     * 如果程序员想ThreadLocal线程局部变量有一个除null以外的初始值，
     * 必须通过子类继承 ThreadLocal 的方式去重写此方法
     * 通常，可以通过匿名内部类的方式实现
     * 
     * @return 当前ThreadLocal的初始值
     */
    protected T initialValue() {
        return null;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

此方法的作用是：返回该线程局部变量的初始值。
（1）这个方法是一个延迟调用方法，从上面的代码我们得知，在set方法还未调用而先调用了get方法才执行，并且仅执行1次。
（2）这个方法缺省实现直接返回一个null。
（3）如果想要一个除null之外的初始值，可以重写此方法。(备注：该方法是一个 protected 的方法，显然是为了让子类覆盖而设计的)

ThreadLocalMap源码分析
ThreadLocal的实际操作是围绕ThreadLocalMap展开的，从以下三个方面进行分析
基本结构:
ThreadLocalMap是ThreadLocal的内部类，没有实现Map接口，用独立的方式实现了Map的功能，其内部的Entry也是独立实现。

（1）成员变量

		/**
         * 初始容量 -- 必须是2的整数此幂
         */
        private static final int INITIAL_CAPACITY = 16;

        /**
         * 存放数据的table，Entry类的定义在下面分析
         * 同样，数组长度必须是2的整数次幂。
         */
        private Entry[] table;

        /**
         * 数组里面entry的个数，可以用于判断table当前使用量是否超过阈值。
         */
        private int size = 0;

        /**
         * 进行扩容的阈值，表使用量大于它的时候进行扩容。
         */
        private int threshold; // Default to 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

跟HashMap类似，INITIAL_CAPACITY 代表这个Map的初始容量；table是一个Entry类型的数组，用于存储数据；size代表表中的存储数目；threshold代表需要扩容时对应size的阈值。
（2）存储结构-Entry

		/**
         * Entry继承WeakReference，并且用ThreadLocal作为key.
         * 如果key为null(entry.get() == null)，意味着key不再被引用，
         * 因此这时候entry也可以从table中清除。
         */
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在ThreadLocalMap中，也是用Entry来保存K-V结构数据的。不过Entry中的key只能是ThreadLocal对象，这点在构造方法中已经限定死了。
另外，Entry继承WeakReference，也就是key(ThreadLocal)是弱引用，其目的是将ThreadLocal对象的生命周期和线程生命周期解绑。

弱引用与内存泄露
有些人认为在使用ThreadLocal的过程中会发现有内存泄露的情况发生，就猜测这个内存泄漏跟Entry中使用了弱引用的key有关，这个理解其实是不对的。
（1）内存泄漏相关概念

• Memory overflow：内存溢出，没有足够的内存可以提供申请者使用。
• Memory leak：内存泄漏是指程序中已动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。内存泄漏的堆积最终导致内存溢出。

（2）弱引用相关概念
Java中的引用有4中类型：强、软、弱、虚。当前这个问题主要涉及到强引用和弱引用：

• 强引用(“Strong” Reference)：就是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还"活着"，垃圾回收器就不会回收这种对象。
• 弱引用(WeakReference)：垃圾回收器一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。(注：若弱引用中的一个对象被其它强引用所引用，这个对象依然不会被回收)

（3）如果key使用强引用
假设ThreadLocalMap中的key使用了强引用，那么会出现内存泄漏吗？
此时ThreadLocal的内存图(实线表示强引用)如下：


综上，ThreadLocal内存泄漏的根源是：由于ThreadLocalMap的生命周期和Thread一样长，如果没有删除对应key就会导致内存泄漏。

（4）为什么使用弱引用

根据以上分析，我们知道：无论是否ThreadLocalMap中的key使用哪种类型引用都无法避免内存泄漏，跟使用弱引用无关。
要避免内存泄漏有两种方式：

1. 使用完ThreadLocal，调用其remove方法删除对应的Entry
2. 使用完ThreadLocal，当前Thread也随之运行结束

相对第一种方式，第二种方式显然更不好控制，特别是使用线程池的时候，线程结束是不会销毁的。
也就是说，只要记得在使用完TheadLocal及时调用remove，无论key是强引用还是弱引用都不会有问题。那么为什么key要用弱引用呢？

事实上，在ThreadLocalMap中的set/getEntry方法中，会对key为null（也即是ThreadLocal为null）进行判断，如果为null的话，那么是会对value置为null的。

这就意味着使用完ThreadLocal，CurrentThread依然运行的前提下，就算忘记调用remove方法，弱引用比强引用可以多一层保障：弱引用的ThreadLocal会被回收，对应的value在下一次ThradLocalMap调用set，get，remove中任一方法的时候会被清除，从而避免内存泄漏。

hash冲突的解决
hash冲突的解决是Map中的一个重要内容。我们以hash冲突的解决为线索，来研究一下ThreadLocalMap的核心源码。
（1）首先从ThreadLocal的set()方法入手
ThreadLocal的set方法已经分析过，其作用是设置当前线程绑定的局部变量：
A、首先获取当前线程，并根据当前线程获取一个Map
B、如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal的引用作为key）
(这里调用了ThreadLocalMap的set方法)
C、如果Map为空，则给该线程创建Map，并设置初始值
（这里调用了ThreadLocalMap的构造方法）
这里有两个地方分别涉及到ThreadLocalMap的两个方法，我们接着分析这两个方法。

（2）构造方法 ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue)

		/**
         * firstkey：本ThreadLocal实例（this）
         * firstValue：要保存的线程本地变量
         */
        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        	// 初始化table（初始容量16）
            table = new Entry[INITIAL_CAPACITY];
            // 计算索引（重点代码）
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            // 设置值
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            // 设置阈值（初始容量的2/3）
            setThreshold(INITIAL_CAPACITY);
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

构造函数首先创建一个长度为16的Entry数组，然后计算出firstKey对应的索引，然后存储到table中，并设置size和threshold。
重点分析： int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
a、关于firstKey.threadLocalHashCode：

	private final int threadLocalHashCode = nextHashCode();

	private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

	/**
     * AtomicInteger 是一个提供原子操作的Integer类，通过线程安全的方式操作加减，
     * 适合高并发情况下的使用
     */
    private static AtomicInteger nextHashCode =
        new AtomicInteger();

	/**
     * 特殊的hash值
     */
    private static final int HASH_INCREMENT = 0x61c88647;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这里定义了一个AtomicInteger 类型，每次获取当前值并加上HASH_INCREMENT ，HASH_INCREMENT = 0x61c88647，这个值跟斐波那契数列（黄金分割数）有关，其主要目的就是为了让哈希码能均匀的分布在2的n次方的数组里，也就是Entry[] table中，这样做可以尽量避免hash冲突。

b、关于& (INITIAL_CAPACITY - 1)
计算hash的时候里面采用了hashCode & (size-1) 算法，这相当于取模运算 hashCode % size 的一个更高效的实现。正是因为这种算法，我们要求size必须是2的整数次幂，这也能保证在索引不越界的前提下，使得hash发生冲突的次数减小。

（3）ThreadLocalMap中的set方法

		
        private void set(ThreadLocal<?> key, Object value) {
            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();
                // ThreadLocal 对应的 key 存在，直接覆盖之前的值
                if (k == key) {
                    e.value = value;
                    return;
                }
				// key为 null, 但是值不为null，说明之前的 ThreadLocal 对象已经被回收了，
				// 当前数组中的 Entry 是一个陈旧（stale）的元素
                if (k == null) {
                	// 用新元素替换陈旧的元素，这个方法进行了不少垃圾清理动作，防止内存泄漏
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
			
			// ThreadLocal 对应的key不存在并且没有找到陈旧的元素，则在空元素的位置创建一个新的Entry
            tab[i] = new Entry(key, value);
            int sz = ++size;
            /**
             * cleanSomeSlots用于清理那些 e.get()==null 的元素，
             * 这种数据key关联的对象已经被回收，所以这个Entry(table[index])可以被置为null。
             * 如果没有清除任何entry，并且当前使用量达到了负载因子所定义(数组长度的2/3)，那么进行
             * rehash(执行一次全表的扫描清理工作)
             */
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

		/**
         * 获取环形数组的下一个索引
         */
        private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

代码执行流程：
A、首先还是根据key计算出索引 i，然后查找 i 位置上的Entry，
B、若是Entry已经存在并且key等于传入的key，那么这时候直接给这个Entry赋新的value值，
C、若是Entry存在，但是key为null，则调用replaceStaleEntry来更换这个key为空的Entry，
D、不断循环检测，直到遇到为null的地方，这时候要是还没在循环过程中return，那么就在这个null的位置新建一个Entry，并且插入，同时size增加1。

最后调用cleanSomeSlots，清理key为null的Entry，最后返回是否清理了Entry，接下来再判断sz是否>= threshold达到了rehash的条件，达到的话就会调用rehash函数执行一次全表的扫描清理。

重点分析： ThreadLocalMap使用 线性探测法 来解决哈希冲突。
该方法一次探测下一个地址，直到有空的地址后插入，若整个空间都找不到空余的地址，则产生溢出。
举个例子，假设当前table长度为16，也就是说如果计算出来key的hash值为14，如果table[14]上已经有值，并且其key与当前key不一致，那么就发生了hash冲突，这个时候将14+1得到15，取table[15]进行判断，这个时候如果还是冲突会回到0，取table[0]，以此类推，直到可以插入。
按照上面的描述，可以把Entry[] table 看成一个环形数组。