Java并发编程之ThreadLocal原理解析

1.ThreadLocal内部结构

1.1 常见误解

如果我们不去看源代码的话，可能会猜测ThreadLocal是这样子设计的：

每个ThreadLocal都创建一个Map，然后用线程作为Map的key，要存储的局部变量作为Map的value，这样就能达到各个线程的局部变量隔离的效果。这是最简单的设计方法，JDK最早期的ThreadLocal 确实是这样设计的，但现在早已不是了。

1.2 现在的设计

但是，JDK后面优化了设计方案，在JDK8中 ThreadLocal的设计是：

每个Thread维护一个ThreadLocalMap，这个Map的key是ThreadLocal实例本身，value才是真正要存储的值Object。

具体过程：

• 每个Thread内部都维护着一个ThreadLocalMap类型的成员变量，可以简单把它理解成Map。

• ThreadLocalMap里面存储着当前ThreadLocal对象(key)和线程的变量副本(value)。

• 由ThreadLocal负责向ThreadLocalMap获取和设置线程的变量值。

• 对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，互不干扰。

1.3 这样设计的好处

• 这样设计之后每个Map存储的Entry数量就会变少。因为之前的存储数量由Thread的数量决定，现在是由ThreadLocal的数量决定。在实际运用当中，往往ThreadLocal的数量要少于Thread的数量。
• 当Thread销毁之后，对应的ThreadLocalMap也会随之销毁，能减少内存的使用。

2.ThreadLocal的核心源码分析

除了构造方法之外， ThreadLocal对外暴露的方法有以下4个：

方法声明	描述
protected T initialValue()	返回当前线程局部变量的初始值
public void set( T value)	设置当前线程绑定的局部变量
public T get()	获取当前线程绑定的局部变量
public void remove()	移除当前线程绑定的局部变量

2.1 ThreadLocalMap源码分析

2.1.1 基本结构

ThreadLocalMap是ThreadLocal的静态内部类，没有实现Map接口，用独立的方式实现了Map的功能，其内部的Entry也是独立实现。

（1）ThreadLocalMap的成员变量

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

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

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

    /**
     * 进行扩容的阈值，表使用量大于它的时候进行扩容。
     */
    private int threshold; // Default to 0

（2） 存储结构 - Entry

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

    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

在ThreadLocalMap中，也是用Entry来保存K-V数据结构的。不过Entry中的key只能是ThreadLocal对象，这点在构造方法中已经限定死了。

​ 另外，Entry继承WeakReference，也就是key（ThreadLocal）是弱引用，其目的是将ThreadLocal对象的生命周期和线程生命周期解绑。

2.2 ThreadLocal的set方法以及相关方法

public void set(T value) {
	// 获得当前线程对象
	Thread t = Thread.currentThread();
	// 获得当前线程对象维护的ThreadLocalMap对象
	ThreadLocalMap map = getMap(t);
	if (map != null) {
		// 如果 map 不为空，则把当前对象ThreadLocal作为 key，和当前线程要保存的变量(value)传入set
		map.set(this, value);
	} else {
		// 如果 map 为空，则创建ThreaLocalMap对象，并传入当前的线程对象，和value
		createMap(t, value);
	}
}

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

// 如果 map 为空进入此方法
void createMap(Thread t, T firstValue) {
	// 把当前对象ThreadLocal和value传入ThreadLocalMap的构造方法
	// 并把对象赋值给当前线程的threaLocals成员变量
	// 这样就创建了ThreadLocalMap，并设置了第一个K-V数据
	t.threadLocals = new ThreadLocalMap(this, firstValue);
}

当map为空时，创建ThreadLocalMap，下面来看看具体的初始化逻辑：

/**
* 构造一个最初包含 (firstKey, firstValue) 的新映射。
* ThreadLocalMaps是懒惰创建的，所以我们只创建
* 当我们至少有一个条目可以放入时为一个。
*/
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
	// 创建了一个数组，初始容量是 INITIAL_CAPACITY = 16
	table = new Entry[INITIAL_CAPACITY];
	// 关键代码，根据key计算在数组中的索引
	int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
	// 设置值
	table[i] = new Entry(firstKey, firstValue);
	// 第一次在数组里添加元素
	size = 1;
	// 设置扩容阈值
	setThreshold(INITIAL_CAPACITY);
}

构造函数首先创建一个长度为16的Entry数组，然后计算出firstKey对应的索引，然后存储到table中，并设置size和threshold。

重点分析： int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1)。

• 关于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;

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

• 关于& (INITIAL_CAPACITY - 1)

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

当map已存在时，就会调用ThreadLocalMap的set方法，这是真正放入键值的方法

/**
 * 设置与键关联的值。
 *  * @param key 当前ThreadLocal对象
 * @param value 要设置的值
*/
private void set(ThreadLocal<?> key, Object value) {
	// tab指向数组
    Entry[] tab = table;
    // 计算数组长度
    int len = tab.length;
    // 关键代码，根据key计算在数组中的索引
    int i = key.threadLocalHashCode & (len-1);
	// 线性探测法查找元素
    for (Entry e = tab[i]; 
    	 e != null; 
    	 e = tab[i = nextIndex(i, len)]) {
    	// 结点不为空，获得这个结点的key
        ThreadLocal<?> k = e.get();
        // 如果这个key是要我们要找的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();
}

上面的执行流程：

• 根据key计算出在数组中的索引。
• 判断该索引上的结点e是否为空。
• 若e为空则直接把当前ThreadLocal(key)和线程要保存的变量(value)封装成Entry放入该索引的位置。
• 若e不为空，则判断该结点的key是否等于我们传过来的key，若等于则把传过来的value覆盖旧的value，然后退出该方法。
• 若key为空，说明该结点的只有value，则调用replaceStaleEntry来更换这个key为空的Entry。
• 若上面两种key的情况都不符合，则不断线性探测，每次移动一位索引继续比较。

注意：

ThreaLocalMap是采用线性探测法来解决哈希冲突。该方法一次探测一个地址，当前地址的结点的key不是我们要找的key时，继续往后一位探测，直到找到我们要的key然后覆盖value，若找不到则说明没有该值的存在；或者找空余的位置插入结点，若找不到空余位置说明数组已满

举个例子，假设当前table长度为16，也就是说如果计算出来key的hash值为14，14 % 16 = 14，如果table[14]上已经有值，并且其key与当前key不一致，那么就发生了hash冲突，这个时候将14加1得到15，15 %16 = 15，取table[15]进行判断，这个时候如果还是冲突继续将15加1得到16，16 % 16 = 0，取table[0],以此类推，直到可以插入。所以，可以把Entry[] table看成一个环形数组。

2.3 ThreadLocal的get方法以及相关方法

/**
 * 返回当前线程中保存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获取对应的存储实体 entry
        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为 key 的 entry
     */
    return setInitialValue();
}

/**
 * 初始化
 *  * @return the initial value 初始化后的值
 */
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);
    // 返回设置的值value
    return value;
}

执行流程：

• 获得当前线程对象，根据当前线程对象获得其ThreadLocalMap。
• 对map进行判空，若不为空则在Map中以当前ThreadLocal的引用作为key来在map中获取对应的结点。
• 若map为空，则进入setInitialValue方法获得初始值(默认是null)，然后用ThreadLocal的引用和初始值value作为firstKey和firstValue创建一个新的Map。
• 对结点进行判空，若不为空则返回该结点的value。
• 若结点为空，则进入setInitialValue方法获得初始值(默认是null)，然后把当前ThreadLocal的引用作为key和初始值value封装成Entry放入Map。

2.4 ThreadLocal的remove方法以及相关方法

/*
	删除此线程本地的当前线程值
*/
public void remove() {
	// 获取当前线程的ThreadLocalMap
	ThreadLocalMap m = getMap(Thread.currentThread());
	  // 如果 map 存在
	  if (m != null) {
	     // 则删除以当前 ThreadLocal 为 key 删除对应的实体 entry
	      m.remove(this);
	}
}

2.5 ThreadLocal的initialValue方法

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

此方法的作用是 返回该线程局部变量的初始值。

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

3. 弱引用和内存泄漏

3.1 内存泄漏相关概念

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

3.2 弱引用相关概念

有些程序员在使用ThreadLocal的过程中会发现有内存泄漏的情况发生，就猜测这个内存泄漏跟Entry中使用了弱引用的key有关系。这个理解其实是不对的。

Java中的引用有4种类型： 强、软、弱、虚。当前这个问题主要涉及到强引用和弱引用：

强引用（“Strong”Reference），就是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还“活着”，垃圾回收器就不会回收这种对象。

弱引用（WeakReference），垃圾回收器一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。

3.3 如果key使用强引用

假设ThreadLocalMap中的key使用了强引用，那么会出现内存泄漏吗？

此时ThreadLocal的内存图（实线表示强引用）如下：

​假设在业务代码中使用完ThreadLocal ，threadLocal Ref被回收了。

​但是因为threadLocalMap的Entry强引用了threadLocal，造成threadLocal无法被回收。

​在没有手动删除这个Entry以及CurrentThread依然运行的前提下，
始终有强引用链 threadRef->currentThread->threadLocalMap->entry，
Entry就不会被回收（Entry中包括了ThreadLocal实例和value），导致Entry内存泄漏。

​也就是说，ThreadLocalMap中的key使用了强引用， 是无法完全避免内存泄漏的。

3.3 如果key使用弱引用

​同样假设在业务代码中使用完ThreadLocal ，threadLocal Ref被回收了。

​由于ThreadLocalMap只持有ThreadLocal的弱引用，没有任何强引用指向threadlocal实例, 所以threadlocal就可以顺利被gc回收，此时Entry中的key=null。

​但是在没有手动删除这个Entry以及CurrentThread依然运行的前提下，也存在有强引用链 threadRef->currentThread->threadLocalMap->entry -> value ，value不会被回收， 而这块value永远不会被访问到了，导致value内存泄漏。

​也就是说，ThreadLocalMap中的key使用了弱引用， 也有可能内存泄漏。

3.4 出现内存泄露的真实原因

比较以上两种情况，我们就会发现，内存泄漏的发生跟ThreadLocalMap中的key是否使用弱引用是没有关系的。

1. 没有手动删除这个Entry
2. CurrentThread依然运行

1. 只要在使用完ThreadLocal，调用其remove方法删除对应的Entry，就能避免内存泄漏。
2. ThreadLocalMap是Thread的一个属性，被当前线程所引用，所以它的生命周期跟Thread一样长。那么在使用完ThreadLocal之后，如果当前Thread也随之执行结束，ThreadLocalMap自然也会被gc回收，从根源上避免了内存泄漏。

3.5 为什么使用弱引用

根据刚才的分析, 我们知道了： 无论ThreadLocalMap中的key使用哪种类型引用都无法完全避免内存泄漏，跟使用弱引用没有关系。

​ 要避免内存泄漏有两种方式：

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

相对第一种方式，第二种方式显然更不好控制，特别是使用线程池的时候，线程结束是不会销毁的。

也就是说，只要记得在使用完ThreadLocal及时的调用remove，无论key是强引用还是弱引用都不会有问题。那么为什么key要用弱引用呢？

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

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