ThreadLocal 与其底层数据结构的介绍

ThreadLocal 是什么

通常情况下，我们创建的变量是可以被任何一个线程访问并修改的。如果想实现每一个线程都有自己的专属本地变量该如何解决呢？ JDK中提供的ThreadLocal类正是为了解决这样的问题。ThreadLocal类主要解决的就是让每个线程绑定自己的值，可以将ThreadLocal类形象的比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。

如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的本地副本，这也是ThreadLocal变量名的由来。他们可以使用 get（） 和 set（） 方法来获取默认值或将其值更改为当前线程所存的副本的值，从而避免了线程安全问题。

ThreadLocal 底层数据结构

先看 Thread 类的内部定义了两个 ThreadLocalMap，ThreadLocalMap 顾名思义是存储 ThreadLocal 的容器；

其包含两个 ThreadLocalMap，一个是此线程私有的 threadLocals ，一个是可继承父类 ThreadLocal 的inheritableThreadLocals；

// Thread 内部也定义了ThreadLocalMap，从而实现线程间的数据隔离
public class Thread implements Runnable {
	...

    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class.
     * 与此线程相关的ThreadLocal值。此映射由ThreadLocal类维护 */
    ThreadLocal.ThreadLocalMap threadLocals = null;

    /*
     * InheritableThreadLocal values pertaining to this thread. This map is
     * maintained by the InheritableThreadLocal class
     * 与此线程相关的 可继承ThreadLocal值。此映射由InheritableThreadLocal类维护.
     */
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
  
    ...

看 ThreadLocal 类的源码：

static class ThreadLocalMap{
    ...
}

其定义了一个静态内部类 ThreadLocalMap，我们可以把 ThreadLocalMap 理解为线程存储私有数据的容器。存取数据时调用的是 ThreadLocalMap 类的 get、set 方法。

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

而 ThreadLocalMap 中定义了一个 Entry 数组，该数组存放一个个 Entry 对象；Entry 对象是以 ThreadLocal 作为 key，任意类型作为 value 的一种键值对：

static class ThreadLocalMap {

    static class Entry extends WeakReference<ThreadLocal<?>> {
        /** The value associated with this ThreadLocal. */
        Object value;

        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
    ...
    //该数组初始大小为16 
    //`private static final int INITIAL_CAPACITY = 16;`
    private Entry[] table;
}

现在数据结构就比较清晰了，一个 Thread 类可以有多个 ThreadLocal 类，一个 Thread 类拥有一个 ThreadLocalMap，该集合并没有实现 map 接口，底层数据结构是数组；键值对Entry(ThreadLocal<?> k, Object v)（多个 ThreadLocal）都存储在 table 数组中，就像Map [{id:1},{name:"张三"},{age:20}]。

该数据结构是为了让每个线程可以关联多个 ThreadLocal 变量。这也就解释了 ThreadLocal 声明的变量为什么在每一个线程都有自己的专属本地变量。

保证 ThreadLocalMap 存取数据的效率，底层也使用了与 HashMap 一致的哈希算法

我们先来看一下 set 方法的源码：

private void set(ThreadLocal<?> key, Object value) {
       Entry[] tab = table;
       int len = tab.length;
       // 此处将ThreadLocal进行hash并与(len-1)，得到的i就是数组的下标
       int i = key.threadLocalHashCode & (len-1);
   
       // 循环遍历Entry[]数组
       for (Entry e = tab[i];
            e != null;
            e = tab[i = nextIndex(i, len)]) {
           ThreadLocal<?> k = e.get();
   
           // 如果当前遍历到的ThreadLocal与传入的ThreadLocal一致，则覆盖value值
           if (k == key) {
               e.value = value;
               return;
           }
   
           // 如果遍历到该位置上的key为null，也就是这个位置为空，那直接new一个Entry放在i位置上
           if (k == null) {
               replaceStaleEntry(key, value, i);
               return;
           }
       }
   
       tab[i] = new Entry(key, value);
       int sz = ++size;
       if (!cleanSomeSlots(i, sz) && sz >= threshold)
           rehash();
   }

简单来说，set 方法会先计算该 ThreadLocal 的数据下标，如果该位置上为空，则新建 Entry 键值对并插入；如果该位置有数据且 key 一致，则覆盖原有 value；如果 for 循环一直找不到对应位置，在循环外直接给 tab[i] 赋新得 Entry

当然在 get 方法时，也会计算 ThreadLocal 的哈希值算出下标为 i 的位置，然后判断该位置 Entry 对象中的 ThreadLocal 是否和该位置上的 key 一致，如果不一致，就判断下一个位置，源码：

private Entry getEntry(ThreadLocal<?> key) {
       // 算出位置i
       int i = key.threadLocalHashCode & (table.length - 1);
       Entry e = table[i];
       if (e != null && e.get() == key)
           // 匹配到相同的ThreadLocal
           return e;
       else
           // 没匹配到相同的ThreadLocal
           return getEntryAfterMiss(key, i, e);
   }
   
   private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
       Entry[] tab = table;
       int len = tab.length;
   	// 遍历对比每一个ThreadLocal
       while (e != null) {
           ThreadLocal<?> k = e.get();
         	// 相等就直接返回，不相等就继续查找，找不到就返回null
           if (k == key)
               return e;
           if (k == null)
               expungeStaleEntry(i);
           else
               i = nextIndex(i, len);
           e = tab[i];
       }
       return null;
   }

ThreadLocal 存在的内存泄露问题

static class ThreadLocalMap {

        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

之前我们看到 ThreadLocalMap 中的 Entry 类继承了弱引用，表示 ThreadLocalMap 中使用的 key 为弱引用，而 value 是强引用。

弱引用的对象拥有更短暂的生命周期，在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会进行回收
所以，如果 ThreadLocal 没有被外部强引用的情况下，在垃圾回收的时候，key 会被清理掉，而 value 不会被清理掉。这样一来，ThreadLocalMap 中就会出现 key 为 null 的 Entry。假如我们不做任何措施的话，value 永远无法被GC 回收，这个时候就可能会产生内存泄露。

ThreadLocalMap 实现中已经考虑了这种情况，在调用 set()、get()、remove() 方法的时候，会清理掉 key 为 null 的记录。使用完 ThreadLocal 方法后 最好手动调用remove()方法

ThreadLocal 也可以是线程共享数据

使用 InheritableThreadLocal 类可以实现多个线程访问 ThreadLocal 的值，我们在主线程中创建一个 InheritableThreadLocal 的实例，然后在子线程中得到这个 InheritableThreadLocal 实例设置的值。
使用ThreadLocal threadLocal = new InheritableThreadLocal();即可