全面理解ThreadLocal（详细简单）（二）-阿里云开发者社区

全面理解ThreadLocal（详细简单）（一）https://developer.aliyun.com/article/1393274

六、ThreadLocalMap的基本结构

前面已经分析了ThreadLocal的几个核心方法实现，我们了解到ThreadLocal实际上都是围绕ThreadLocalMap来展开的，ThreadLocalMap的源码相对比较复杂，我们从下面几个方面进行讨论。

基本结构：

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

static class ThreadLocalMap {
    /**
     * Entry继承弱引用对象WeakReference
     */
    static class Entry extends WeakReference<ThreadLocal<?>> {
        /** The value associated with this ThreadLocal. */
        Object value;
        //key其实就是ThreadLocal对象
        //v其实就是线程局部变量的副本
        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
    /**
     * 初始容量大小，必须是2的n次幂
     */
    private static final int INITIAL_CAPACITY = 16;
    /**
     * 存放数据的entry数组对象
     */
    private Entry[] table;
    /**
     * 数组里面entry的数量
     */
    private int size = 0;
    /**
     * 扩容阈值，容量大于它时会扩容
     */
    private int threshold; // Default to 0
    //省略........
}

跟HashMap类似，INITIAL_CAPACITY就是初始化容量，必须是2的n次幂，table是一个Entry类型的数组，用于存储数据；size代表表中的存储数目；threshold代表需要扩容时对应的size的阈值；

存储结构 - Entry：

//Entry继承自WeakReference，并且用ThreadLocal作为key
//如果key为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;
    }
}

在ThreadLocalMap中，也是用Entry来保存K-V结构数据的。不过Entry中的key只能是ThreadLocal对象。另外，Entry继承自WeakReference，也就是key(ThreadLocal)是弱引用，其目的是将ThreadLocal对象的生命周期和线程Thread生命周期解绑。

七、ThreadLocal的内存泄露问题

弱引用和内存泄露

有些时候，我们在使用ThreadLocal的时候可能会发现有内存泄露的情况发生，就猜测这个内存泄露跟Entry中使用了弱引用的key有关系，其实这个理解是不对的。

先来看下内存泄露的概念：

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

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

强引用：就是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还活着，垃圾回收器就不会回收这种对象；
弱引用：垃圾回收器一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存；

如果key使用强引用：

分析：

假设在业务代码中使用完ThreadLocal，ThreadLocal Ref也就被回收了；
但是因为ThreadLocalMap中的Entry中的key强引用了threadLocal，造成threadLocal无法被回收；
在没有手动删除这个Entry对象以及当前线程CurrentThread依然还在运行的前提下，始终有强引用链threadRef -> currentThread -> threadLocalMap -> Entry，这样entry就不会被回收（entry中包含了threadLocal实例和value），导致entry内存泄露；

总结：ThreadLocalMap中的key使用了强引用，是无法完全避免内存泄露问题的。

如果key使用弱引用：

分析：

假设在业务代码中使用完ThreadLocal，ThreadLocal Ref也就被回收了；
由于ThreadLocalMap的key只持有了ThreadLocal的弱引用，没有任何强引用链指向ThreadLocal对象，此时垃圾回收器就能顺利回收ThreadLocal对象，回收完后，此时entry中的key就是null了。
但是在没有手动删除这个Entry对象以及当前线程CurrentThread依然还在运行的前提下，始终有强引用链threadRef -> currentThread -> threadLocalMap -> Entry -> value，value不会被回收，而这块value永远不会被访问到了，导致value的内存泄露；

总结：ThreadLocalMap中的key使用了弱引用，也是无法完全避免内存泄露问题的。

比较上面两种情况，可以发现，内存泄露的发生跟ThreadLocalMap中的key是否使用弱引用是没有关系的。那么内存泄露的真正原因是什么呢？

我们发现，以上两种内存泄露的情况中，都有两个前提：

没有手动删除这个entry对象，只要使用完ThreadLocal对象，调用其remove方法删除对应的entry，就会避免内存泄露；
currentThread当前线程依然在运行；

由于ThreadLocalMap是Thread的一个成员属性，被当前线程所引用，所以它的生命周期跟线程Thread一样长。那么在使用完ThreadLocal时，如果当前Thread也随之执行结束，ThreadLocalMap自然也会被垃圾回收器回收，从根源上避免了内存泄露。

综上，ThreadLocal内存泄露的根源是：由于ThreadLocalMap的生命周期跟Thread当前线程一样长，如果没有手动删除对应可以就会导致内存泄露。

既然强引用和弱引用都无法避免内存泄露问题，那么ThreadLocalMap的key要使用弱引用呢？

事实上，在ThreadLocalMap中的set、getEntry方法中，会对key为null的ThreadLocal进行判断，如果为null的话，它是会对value置空的。这就意味着使用完ThreadLocal，当前线程依然运行的前提下，就算忘记调用remove方法，弱引用比强引用可以多一层保障。弱引用的ThreadLocal会被回收，对应的value在下一次ThreadLocalMap调用set、get、remove中的任意一个方法的时候会被清除，从而避免内存泄露。

八、ThreadLocalMap的hash冲突问题

hash冲突的解决是Map中的一个重要内容，我们以hash冲突的解决为线索，来研究一下ThreadLocalMap的核心源码。

(1)、首先从ThreadLocalMap的构造方法入手

//firstKey: 当前ThreadLocal实例
//firstValue: 要保存的线程本地变量
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    //初始化entry数组    
    table = new Entry[INITIAL_CAPACITY];
    //计算索引
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    //设置值
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    //设置扩容阈值
    setThreshold(INITIAL_CAPACITY);
}

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

重点分析一下跟hash冲突有关的代码，也就是计算索引的代码：

int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);

关于firstKey.threadLocalHashCode：

//threadLocal的hash值
private final int threadLocalHashCode = nextHashCode();
//返回下一个hash值
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}
//使用AtomicInteger通过原子操作类线程安全的方式操作加减，适合高并发情况下的使用
private static AtomicInteger nextHashCode = new AtomicInteger();
//特殊的一个hash值
private static final int HASH_INCREMENT = 0x61c88647;

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

关于& (INITIAL_CAPACITY - 1)

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

ThreadLocalMap的set方法：

private void set(ThreadLocal<?> key, Object value) {
    //获取到entry[]数组
    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)]) {  //nextIndex()方法: 获取环形数组的下一个索引
        ThreadLocal<?> k = e.get();
        //ThreadLocal对应的key存在，直接覆盖之前的值
        if (k == key) {
            e.value = value;
            return;
        }
        //key为null,但是值不为null,说明之前的ThreadLocal对象已经被回收了
        //当前数组中的Entry是一个陈旧的元素
        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可以被置空
    //如果没有清除任何entry，并且当前使用量达到了负载因子所定义的阈值，那么进行
    //rehash，执行一次全表的扫描清理工作。
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}
//获取环形数组的下一个索引
private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0);
}

set()方法代码执行流程：

首先还是根据key计算出索引，然后查找对应索引位置上的entry；
如果entry已经存在并且key等于传入的key，那么这时候直接给这个entry赋予新的value值；
如果entry存在，但是key是null，则调用replaceStaleEntry来更换这个key为null的entry；
不断循环检测，直到遇到为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看成一个环形数组。

以上就是关于ThreadLocal的一些分析和总结，希望对大家有所帮助。

全面理解ThreadLocal（详细简单）（二）

六、ThreadLocalMap的基本结构

七、ThreadLocal的内存泄露问题

八、ThreadLocalMap的hash冲突问题

热门文章

最新文章

相关电子书