ThreadLocal

ThreadLocal是什么？

ThreadLocal是一个本地线程 副本变量工具类。主要用于将私有线程和该线程存放的副本对象做一个映射，各个线程之间的变量互不干扰，在高并发场景下，可以实现无状态的调用，特别适用于各个线程依赖不同的变量值完成的场景。

 

---

 

ThreadLocal的内部结构

 

 

从上面的结构图，可以看到ThreadLocal的核心机制：

a.每个Thread线程内部都有一个Map

b.Map里面存储线程本地对象（Key）和线程的变量副本（value）

c.但是，Thread内部的Map是由ThreadLocal维护的，由ThreadLocal负责向Map获取和和设置线程的变量值。

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

Thread线程内部的Map在类中的描述如下

public class Thread implements Runnable { /* ThreadLocal values pertaining to this thread. This map is maintained * by the ThreadLocal class. */ ThreadLocal.ThreadLocalMap threadLocals = null; }

 

---

 

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);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null)
            return (T)e.value;
    }
    return setInitialValue();
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

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

protected T initialValue() {
    return null;
}

 

获取当前线程的ThreadLocalMap对象的threadlocals。

从Map中获取线程存储的 K - V Entry节点。

从Entry节点获取存储的value副本值返回。

如果Map为空的话返回初始值 null，即线程变量副本为null。

 

---

 

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) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

 

获取当前线程的成员变量Map。

Map非空，则重新将ThreadLocal和新的value副本放入到 Map中。

Map为空，则对线程的 成员变量ThreadLocamMap进行初始化创建，并 将ThreadLocal和value副本放入Map中

 

---

 

ThreadLocalMap

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

 

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

 

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

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

 

Entry继承自WeakReference（弱引用，生命周期只能存活到下此次GC前），但只有Key是弱引用类型，Value并非弱引用。

ThreadLocalMap的成员变量

static class ThreadLocalMap {
    /**
     * The initial capacity -- MUST be a power of two.
     */
    private static final int INITIAL_CAPACITY = 16;

    /**
     * The table, resized as necessary.
     * table.length MUST always be a power of two.
     */
    private Entry[] table;

    /**
     * The number of entries in the table.
     */
    private int size = 0;

    /**
     * The next size value at which to resize.
     */
    private int threshold; // Default to 0
}

 

 

---

 

Hash冲突怎么解决？

和HashMap的最大的不通在于，ThreadLocalMap结构非常简单，没有next引用，也就是说ThreadLocalMap中解决Hash冲突的方式并非链表的方式，而是采用线性探测的方式，所谓线性探测，就是根据 key 的 hashcode 值确定元素在 table数组中的位置，如果发现这个位置上已经有其他key值的元素被占用，则利用固定的 算法寻找一定步长的下个位置，依次判断，直到能够找到存放的位置。

ThreadLocalMap解决Hash冲突的方式 就是简单的步长加 1 或减 1， 寻找下一个相邻的位置

/** * Increment i modulo len. */ private static int nextIndex(int i, int len) { return ((i + 1 < len) ? i + 1 : 0); } /** * Decrement i modulo len. */ private static int prevIndex(int i, int len) { return ((i - 1 >= 0) ? i - 1 : len - 1); }

显然ThreadLocalMap采用线性探测的方式 解决Hash冲突的效率很低，如果有大量不同的ThreadLocal对象放入Map中时发生冲突，或者发生二次冲突，则效率很低。

所以 建议：每个线程只存一个变量，这样的话所有的线程存放到 Map 中的 Key 都是相同的ThreadLocal，如果一个线程要存放多个变量，就需要创建多个 ThreadLocal，多个 ThreadLocal放入Map中时会极大的增加Hash冲突的可能。

 

---

 

ThreadLocalMap的问题

由于ThreadLocalMap时弱引用，而 value是强引用。这就导致了 一个问题，ThreadLocal在没有外部对象强引用时，发生GC时引用key会被回收 ，而Value不会回收，如果创建ThreadLocal的线程一直持续运行，那么这个Entry对象中的value就有可能一直得不到 回收，发生内存泄露。

如何避免泄露

既然Key时 弱引用，那么 我们要做的事，就是在调用ThreadLocal的get、set方法时完成后再调用 remove方法，将Entry节点和Map的引用关系 移除，这样整个Entry对象在GC Roots分析后就变成不可达了，下次 GC的时候就可以被回收。

 

 

---

 

总结

每个ThreadLocal只能保存一个变量副本，如果想要上线 一个线程 能够保存多个副本以上，就需要创建多个ThreadLocal。

ThreadLocal内部的ThreadLocalMap键为弱引用，会有内存泄露的 风险。

适用于无状态，副本变量独立后不影响业务逻辑的高并发场景。如果业务逻辑 强依赖于副本变量，则不适用于ThreadLocal解决，需要另寻解决方案。