ThreadLocal与ThreadLocalMap源码分析

ThreadLocal类

该类主要用于不同线程存储自己的线程本地变量。本文先通过一个示例简单介绍该类的使用方法，然后从ThreadLocal类的初始化、存储结构、增删数据和hash值计算等几个方面，分析对应源码。采用的版本为jdk1.8。

ThreadLocal-使用方法

ThreadLocal对象可以在多个线程中被使用，通过set()方法设置线程本地变量，通过get()方法获取设置的线程本地变量。我们先通过一个示例简单了解下使用方法：

public static void main(String[] args){
    ThreadLocal<String> threadLocal = new ThreadLocal<>();
    // 线程1
    new Thread(()->{
        // 查看是否有初始值
        System.out.println("线程1的初始值:"+threadLocal.get());
        // 设置线程1的值
        threadLocal.set("V1");
        // 输出
        System.out.println("线程1的值:"+threadLocal.get());
        // 等待一段时间，等线程2设置值后再查看线程1的值
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程1的值:"+threadLocal.get());
    }).start();
    // 线程2
    new Thread(()->{
        // 等待线程1设置初始值
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 查看线程2的初始值
        System.out.println("线程2的值:"+threadLocal.get());
        // 设置线程2的值
        threadLocal.set("V2");
        // 查看线程2的值
        System.out.println("线程2的值:"+threadLocal.get());
    }).start();
}

由于threadlocal设置的值是在每个线程中都有一个副本的，线程之间不会互相影响。代码运行的结果如下所示：

线程1的初始值:null
线程1的值:V1
线程2的值:null
线程2的值:V2
线程1的值:V1

ThreadLocal-初始化

ThreadLocal类只有一个无参的构造方法，如下所示：

/**
 * Creates a thread local variable.
 * @see #withInitial(java.util.function.Supplier)
 */
public ThreadLocal() {
}

但其实还有一个带参数的构造方法，不过是它的子类。ThreadLocal中定义了一个内部类SuppliedThreadLocal，为继承自ThreadLocal类的子类。可以通过该类进行给定初始值的初始化，其定义如下：

static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {

        private final Supplier<? extends T> supplier;

        SuppliedThreadLocal(Supplier<? extends T> supplier) {
            this.supplier = Objects.requireNonNull(supplier);
        }

        @Override
        protected T initialValue() {
            return supplier.get();
        }
    }

通过TheadLocal threadLocal = Thread.withInitial(supplier);这样的语句可以进行给定初始值的初始化。在某个线程第一次调用get()方法时，会执行initialValue()方法设置线程变量为传入supplier中的值。

public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
        return new SuppliedThreadLocal<>(supplier);
    }

ThreadLocal-存储结构

在jdk1.8版本中，使用的是TheadLocalMap这一个容器存储线程本地变量。


该容器的设计思想和HashMap有很多共同之处。比如：内部定义了Entry节点存储键值对（使用ThreadLocal对象作为键）；使用一个数组存储entry节点；设定一个阈值，超过阈值时进行扩容；通过键的hash值与数组长度进行&操作确定下标索引等。但也有很多不同之处，具体我们在后续介绍ThreadLocalMap类时再详细分析。

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

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
    // 存储元素的数组
    private Entry[] table;
    // 容器内元素数量
    private int size = 0;
    // 阈值
    private int threshold; // Default to 0
    // 修改和添加元素
    private void set(ThreadLocal<?> key, Object value){
        ...
    }
    // 移除元素
    private void remove(ThreadLocal<?> key) {
        ...
    }
    ...
}

ThreadLocal-增删数据

ThreadLocal类提供了get(),set()和remove()方法来操作当前线程的threadlocal变量副本。底层则是基于ThreadLocalMap容器来实现数据操作。


不过要注意的是：ThreadLocal中并没有ThreadLocalMap的成员变量，ThreadLocalMap对象是Thread类中的一个成员，所以需要通过通过当前线程的Thread对象去获取该容器。


每一个线程Thread对象都会有一个map容器，该容器会随着线程的终结而回收。


设置线程本地变量的方法。

public void set(T value) {
    // 获取当前线程对应的Thread对象，其是map键值对中的健
    Thread t = Thread.currentThread();
    // 获取当前线程对象的容器map
    ThreadLocalMap map = getMap(t);
    // 如果容器不为null,则直接设置元素。否则用线程对象t和value去初始化容器对象
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

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

// 创建map容器，本质是初始化Thread对象的成员变量threadLocals
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

获取线程本地变量的方法。

public T get() {
    // 获取当前线程对象
    Thread t = Thread.currentThread();

    // 获取当前线程对象的容器map
    ThreadLocalMap map = getMap(t);

    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);

        // 如果容器不为null且容器内有当前threadlocal对象对应的值，则返回该值
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }

    // 如果容器为null或者容器内没有当前threadlocal对象绑定的值，则先设置初始值并返回该初始值
    return setInitialValue();
}

// 设置初始值。主要分为两步:1.加载和获取初始值;2.在容器中设置该初始值。
// 第二步其实和set(value)方法实现一模一样。
private T setInitialValue() {

    // 加载并获取初始值,默认是null。如果是带参初始化的子类SuppliedThreadLocal，会有一个输入初始值。
    // 当然也可以继承ThreadLocal类重写该方法设置初始值
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);

    // 如果容器不为null,则直接设置元素。否则用线程对象t和value去初始化容器对象
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

移除线程本地变量的方法

public void remove() {
    // 如果容器不为null就调用容器的移除方法，移除和该threadlocal绑定的变量
     ThreadLocalMap m = getMap(Thread.currentThread());
     if (m != null)
         m.remove(this);
 }

ThreadLocal-hash值计算

ThreadLocal的hash值用于ThreadLocalMap容器计算数组下标。类中定义threadLocalHashCode表示其hash值。类中定义了静态方法和静态原子变量计算hash值，也就是说所有的threadLocal对象共用一个增长器。

// 当前ThreadLocal对象的hash值
private final int threadLocalHashCode = nextHashCode();

// 用来计算hash值的原子变量，所有的threadlocal对象共用一个增长器
private static AtomicInteger nextHashCode = new AtomicInteger();

// 魔法数字，使hash散列均匀
private static final int HASH_INCREMENT = 0x61c88647;

// 计算hash值的静态方法
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

我们使用同样的方法定义一个测试类，定义多个不同测试类对象，看看hash值的生成情况。如下所示，可以看到hash值都不同，是共用的一个增长器。

public class Test{

    private static final int HASH_INCREMENT = 0x61c88647;
    public static AtomicInteger nextHashCode = new AtomicInteger();
    public final int nextHashCode = nextHashCode();
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

    public static void main(String[] args){
        for (int i = 0; i < 5; i++) {
            Test test = new Test();
            System.out.println(test.nextHashCode);
        }
    }
    // 输出的hash值

    0
    1640531527
    -1013904242
    626627285
    -2027808484
}

ThreadLocalMap类

ThreadLocalMap类是ThreadLocal的内部类。其作为一个容器，为ThreadLocal提供操作线程本地变量的功能。每一个Thread对象中都会有一个ThreadLocalMap对象实例(成员变量threadLocals，初始值为null)。因为map是Thread对象的非公共成员，不会被并发调用，所以不用考虑并发风险。


后文将从数据存储设计、初始化、增删数据等方面分析对应源码。

ThreadLocalMap-数据存储设计

该map和hashmap类似，使用一个Entry数组来存储节点元素，定义size变量表示当前容器中元素的数量,定义threshold变量用于计算扩容的阈值。

// Entry数组
private Entry[] table;

// 容器内元素个数
private int size = 0;

// 扩容计算用阈值
private int threshold;

不同的是Entry节点为WeakReference类的子类，使用引用字段作为键，将弱引用字段（通常是ThreadLocal对象）和值绑定在一起。使用弱引用是为了使得threadLocal对象可以被回收，(如果将key作为entry的一个成员变量，那线程销毁前，threadLocal对象不会被回收掉，即使该threadLocal对象不再使用）。

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

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

ThreadLocalMap-初始化

提供了带初始键和初始值的map构造方法，还有一个基于已有map的构造方法(用于ThreadLocal的子类InheritableThreadLocal初始化map容器，目的是将父线程的map传入子线程，会在创建子线程的过程中自动执行）。如下所示：

// 基于初始键值的构造函数
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    // 基于输入键值构建节点
    table = new Entry[INITIAL_CAPACITY];

    // 根据键的hash值计算所在数组下标
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);

    // 采用懒加载的方式，只创建一个必要的节点
    table[i] = new Entry(firstKey, firstValue);
    size = 1;

    // 设置阈值为初始长度的2/3，初始长度默认为12，那么阈值为为8
    setThreshold(INITIAL_CAPACITY);
}

// 基于已有map的构造函数
private ThreadLocalMap(ThreadLocalMap parentMap) {
    // 获取传入map的节点数组
    Entry[] parentTable = parentMap.table;

    int len = parentTable.length;
    setThreshold(len);
    // 构造相同长度的数组
    table = new Entry[len];

    // 深拷贝传入数组中各个节点到当前容器数组
    // 注意这里因为采用开放地址解决hash冲突，拷贝后的元素在数组中的位置与原数组不一定相同
    for (int j = 0; j < len; j++) {

        // 获取数组各个位置上的节点
        Entry e = parentTable[j];
        if (e != null) {
            @SuppressWarnings("unchecked")
            ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
            if (key != null) {

                //确保key为InheritableThreadLocal类型，否则抛出UnsupportedOperationException
                Object value = key.childValue(e.value);
                Entry c = new Entry(key, value);

                // 根据hash值和数组长度，计算下标
                int h = key.threadLocalHashCode & (len - 1);

                // 这里采用开放地址的方法解决hash冲突
                // 当发生冲突时，就顺延到数组下一位，直到该位置没有元素
                while (table[h] != null)
                    h = nextIndex(h, len);
                table[h] = c;
                size++;
            }
        }
    }
}

ThreadLocalMap-移除元素

这里将移除元素的方法放在前面，是因为其它部分会频繁使用过时节点的移除方法。先理解这部分内容有助于后续理解其他部分。


根据key移除容器元素的方法：

 private void remove(ThreadLocal<?> key) {
    // 计算索引下标
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);

    // 从下标i处开始向后寻找是否有key对应节点，直到遇到Null节点
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {

        // 如果遇到key对应节点，执行移除操作
        if (e.get() == key) {
            // 移除节点的键（弱引用）
            e.clear();
            // 移除该过时节点
            expungeStaleEntry(i);
            return;
        }
    }
}

移除过时节点的执行方法:

移除过时节点除了将该节点置为null之外，还要对该节点之后的节点进行移动，看看能不能往前找合适的空格转移。

这种方法有点类似jvm垃圾回收算法的标记-整理方法。都是将垃圾清除之后，将剩余元素进行整理，变得更紧凑。这里的整理是需要强制执行的，目的是为了保证开放地址法一定能在连续的非null节点块中找到已有节点。(试想，如果把过时节点移除而不整理，该节点为null，将前后节点分开了。而如果后面有某个节点hash计算的下标在前面的节点块，在查找节点时通过开放地址会找不到该节点)。示意图如下：

private int expungeStaleEntry(int staleSlot) {
    // 获取entyy数组和长度
    Entry[] tab = table;
    int len = tab.length;

    // 清除staltSlot节点的值的引用，清除节点的引用
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    // 容器元素个数-1
    size--;

    // 清除staleSlot节点后的整理工作
    // 将staleSlot索引后的节点计算下标往前插空移动
    Entry e;
    int i;
    // 遍历连续的非null节点，直到遇到null节点
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        // case1:如果遍历到的节点是过时节点，将该节点清除，容器元素数量-1
        if (k == null) {
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            // case2：如果遍历到的节点不是过时节点，重新计算下标
            int h = k.threadLocalHashCode & (len - 1);
            // 当下标不是当前位置时，从hash值计算的下标h处，开放地址往后顺延插空
            if (h != i) {
                // 先将该节点置为null
                tab[i] = null;

                // 找到为null的节点，插入节点
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}

移除所有过时节点的方法：很简单，全局遍历，移除所有过时节点。

private void expungeStaleEntries() {
    Entry[] tab = table;
    int len = tab.length;
    for (int j = 0; j < len; j++) {
        Entry e = tab[j];
        // 遇到过时节点，清除整理该节点所在的连续块
        if (e != null && e.get() == null)
            expungeStaleEntry(j);
    }
}

尝试去扫描一些过时节点并清除节点，如果有节点被清除会返回true。这里只执行了logn次扫描判断，是为了在不扫描和全局扫描之间找到一种平衡，是上面的方法的一个平衡。

private boolean cleanSomeSlots(int i, int n) {
    boolean removed = false;
    Entry[] tab = table;
    int len = tab.length;
    do {
        i = nextIndex(i, len);
        Entry e = tab[i];
        // 遇到过时节点，清除整理该节点所在连续块
        if (e != null && e.get() == null) {
            n = len;
            removed = true;
            // 从该连续块后第一个null节点开始
            i = expungeStaleEntry(i);
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}

ThreadLocalMap-获取元素

获取容器元素的方法：

// 根据key快速查找entry节点
private Entry getEntry(ThreadLocal<?> key) {
    // 通过threadLocal对象(key)的hash值计算数组下标
    int i = key.threadLocalHashCode & (table.length - 1);

    // 取对应下标元素
    Entry e = table[i];

    if (e != null && e.get() == key)
        return e;
    else
        // 查找不到有两种情况：
        // 1.对应下标桶位为空
        // 2对应下标桶位元素不是key关联的entry(开放地址解决hash冲突导致的)
        return getEntryAfterMiss(key, i, e);
}

// 初次查找失败后再次查找entry节点
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    // 获取entry数组及长度
    Entry[] tab = table;
    int len = tab.length;

    // 如果e为null，说明对应下标桶位为空，找不到key对应的entry
    // 如果e不为null,则用解决hash冲突时的方法(顺延数组下一位)一直找下去，直到找到或e为null
    while (e != null) {
        ThreadLocal<?> k = e.get();
        if (k == key)
            return e;

        // 在寻找的过程中如果节点的key,即ThreadLocal已经被回收(被弱引用的对象可能会被回收)
        // 则移除过时的节点,移除过时节点的方法分析见移除元素部分
        if (k == null)
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    // 没有找到，返回null
    return null;
}

ThreadLocalMap-增加和修改元素

增加和修改容器元素的方法:

这里在根据hash值计算出下标后，由于是开放地址解决hash冲突，会顺序向后遍历直到遇到null或遇到key对应的节点。

这里会出现三种情况:


case1:遍历时找到了key对应节点,这时直接修改节点的值即可；


case2:遍历中遇到了有过时的节点(key被回收的节点)；


case3:遍历没有遇到过时的节点，也没有找到key对应节点，说明此时应该插入新节点（用输入键值构造新节点）。因为是增加新元素，所以可以容量会超过阈值。在删除节点后容量如果超过阈值，则要进行扩容操作。

private void set(ThreadLocal<?> key, Object value) {
    // 获取数组，计算key对应的数组下标
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);

    // 从下标i开始，顺序遍历数组(顺着hash冲突开放地址的路径),直到节点为null
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        // 获取遍历到的节点的key
        ThreadLocal<?> k = e.get();

        // case1:命中key，说明已存在key对应节点，修改value值即可
        if (k == key) {
            e.value = value;
            return;
        }

        // case2:如果遍历到的节点的key为null，说明该threadLocal对象已经被回收
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    // case3:遍历节点直到null都没有找到对应key，说明map中没有key对应entry
    // 则在该位置用输入键和值新建一个entry节点
    tab[i] = new Entry(key, value);

    int sz = ++size;
    // 判断是否清理过时节点后，在判断是否需要扩容
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

case2:增加和修改过程中遇到已经过时的节点的处理。这里的参数staleSlot表示key计算的下标开始往后遇到的第一个过时节点，不管map中有无key对应的节点，该位置之后一定会存入key的节点。这里定义了一个变量slotToExpunge，其含义是左右连续非null的entry块中第一个过时节点（记录该位置是为了后续清除过时节点可以从slotToExpunge处开始）。示意如下：

这步操作有两种情况:


casse2.1:从过时节点staleSlot往后查找遇到key对应节点，则将staleSlot处节点与key对应节点交换。然后清除整理连续块。


casse2.2:没遇到key对应节点，说明map中不存在key对应节点，则新建一个节点填入staleSlot处。然后清除整理连续块。

private void replaceStaleEntry(ThreadLocal<?> key, Object value,int staleSlot) {
    // 获取entry数组和长度
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    // 往前移动寻找第一个过时节点(直到遇到null)，如果没找到的话说明第一个过时节点为staleslot处节点
    // slotToExpunge表示连续块中第一个过时节点
    int slotToExpunge = staleSlot;
    for (int i = prevIndex(staleSlot, len); (e = tab[i]) != null; i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;

    // 从输入下标staleSlot向后找到第一个出现的key对应的节点或过时的节点(key被回收的节点)
    for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();

        // case2.1:如果找到key对应的节点，则用staleSlot处节点和该节点交换，以保持hash表的顺序(hash冲突时顺序向后寻找)
        // 交换后的staleSlot节点及其之前的过时节点会被清除
        if (k == key) {
            // 交换staleSlot处节点和key对应节点
            e.value = value;

            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;

            // 更新slotToExpunge的值，使其保持连续块中第一个过时节点的特性，方便后续清理过时节点。
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;

            // 从slotToExpunge开始清除整理连续块
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

       // 如果遇到过时节点，更新slotToExpunge的值
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // case2.2:没有找到key对应节点，增加新节点并填入staleSlot处
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);

    // 这里如果slotToExpunge=staleSlot，说明连续块中只有一个过时节点，且已经被新建节点填入，就不需要再整理。
    // 如果除了原staleSlot处,还有其它过时节点，从slotToExpunge开始清除整理连续块
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

case3:增加元素后可能超过阈值导致的扩容处理

private void rehash() {
    // 清除所有过时节点
    expungeStaleEntries();

    // 在清除所有过时节点后，如果数量超过3/4的阈值，则进行扩容处理
    // setThreshold()方法非公有，threshold值一直为数组长度的2/3,所以这里是超过数组长度一半就进行扩容
    if (size >= threshold - threshold / 4)
        resize();
}

/**
 * 双倍扩容
 */
private void resize() {
    // 获取旧数组和长度
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    // 新数组长度为原来的两倍
    int newLen = oldLen * 2;
    Entry[] newTab = new Entry[newLen];
    int count = 0;

    // 遍历原数组元素
    for (int j = 0; j < oldLen; ++j) {
        Entry e = oldTab[j];

        // 如果为非null节点
        if (e != null) {
            ThreadLocal<?> k = e.get();
            // 如果是过时节点，则将value置为null,可以使得value的实体尽快被回收
            if (k == null) {
                e.value = null; // Help the GC
            } else {
                // 如果是正常节点，计算下标，重新填入新数组(开放地址解决hash冲突)
                int h = k.threadLocalHashCode & (newLen - 1);
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                // 新数组元素个数+1
                count++;
            }
        }
    }

    // 重新设置阈值
    setThreshold(newLen);
    size = count;
    // 将变量table指向新数组
    table = newTab;
}

ThreadLocalMap-内存泄露问题以及对设计的一些思考

先来聊一聊内存泄漏这个概念。我的理解是有一块内存空间，如果不再被使用但又不能被垃圾回收器回收掉，那么就相当于这块内存少了这块空间，即出现了内存泄露问题。如果内存泄露的空间一直在积累，那么最终会导致可用空间一直减少，最终可能导致程序无法运行。

ThreadLocalMap中也是有可能会出现该问题的，map中entry节点的key为弱引用，如果key没有其它强引用，是会被垃圾收集器回收的。回收之后，map中该节点的value就不会再被使用，但value又被entry节点强引用，不会被回收。这就相当于value这块内存空间发生了泄露。所以能看到在源码中很多方法都进行了清除过时节点的操作，为的就是尽量避免内存泄漏。

在看源码时，一直在思考为什么entry节点的键要采用弱引用的方式。不妨反过来思考，如果entry节点将threadLocal对象作为一个成员变量，而不是采用弱引用的方式，那么entry节点一直对key和value保持着强引用关系，即使threadlocal对象在其它地方都不再使用,该对象也不会被回收。这就会导致entry节点永远不会被回收(只要线程不终结)，而且也不能主动去判断是否切断map中threadlocal对象的引用（不知道是否还有其它地方引用到了）。

因为map是Thread对象的一个成员变量，线程不终结，map是不会被回收的，如果发生了内存泄露的问题，可能会一直积累下去，最终导致程序发生异常。而key采用弱引用加之主动的判断过时节点(判断是否过时很简单，看key是否为null即可)并进行清除处理可以最大限度的减少内存泄露的发生。