【Java基础】ThreadLocal

谁借莪１个温暖的怀抱￠ 2022-09-03 00:14 106阅读 0赞

## ThreadLocal是啥 ##

**ThreadLocal并不是新生事物，早在JDK 1.2的版本中就已经出现了。JDK 1.2发布于1998年12月，距今已经有22年的历史。JDK 1.2是Java发展史的一座里程碑，涌现了很多开创性的功能，例如本文要说的ThreadLocal。**

**ThreadLocal为解决多线程程序的并发问题提供了一种新的思路，使用这个工具类可以很简洁地编写出优美的多线程程序。但是，ThreadLocal很容易让人望文生义，想当然地认为是一个“本地线程”。其实，ThreadLocal并不是一个Thread，而是Thread的局部变量，所以有人觉得它命名为ThreadLocalVariable更容易让人理解一些。**

**当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。从线程的角度看，目标变量就像是线程的本地变量，这也是类名中“Local”所要表达的意思。**

## ThreadLocal应用场景 ##

**ThreadLocal 主要是用在多线程的场景中**

*  **保存线程上下文信息，在任意需要的地方可以获取**
 *  **线程安全，避免某些情况需要考虑线程安全必须同步带来的性能损失**

## ThreadLocal原理 ##

**ThreadLocal类代码不长，JDK1.8只有722行（算上注释），有几个关键的成员：内部静态类ThreadLocalMap，是一个简化的HashMap， Entry类型的table数组保存元素，元素为Entry类型，Entry是ThreadLocalMap的静态内部类，其继承了WeakReference<ThreadLocal<?>>，Entry是一个key-value格式，key是ThreadLocal对象，value就是需要保存的本地对象，值得注意是这里key值ThreadLocal对象是一个弱引用，为什么采用弱引用后面解释。**

static class ThreadLocalMap { 
    
        /** * The entries in this hash map extend WeakReference, using * its main ref field as the key (which is always a * ThreadLocal object). Note that null keys (i.e. entry.get() * == null) mean that the key is no longer referenced, so the * entry can be expunged from table. Such entries are referred to * as "stale entries" in the code that follows. */
        static class Entry extends WeakReference<ThreadLocal<?>> { 
            /** The value associated with this ThreadLocal. */
            Object value;
    
            Entry(ThreadLocal<?> k, Object v) { 
                super(k);
                value = v;
            }
        }
    
        /** * The table, resized as necessary. * table.length MUST always be a power of two. */
        private Entry[] table;
    
        /** * Construct a new map initially containing (firstKey, firstValue). * ThreadLocalMaps are constructed lazily, so we only create * one when we have at least one entry to put in it. */
        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) { 
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }
    
        /** * Get the entry associated with key. This method * itself handles only the fast path: a direct hit of existing * key. It otherwise relays to getEntryAfterMiss. This is * designed to maximize performance for direct hits, in part * by making this method readily inlinable. * * @param key the thread local object * @return the entry associated with key, or null if no such */
        private Entry getEntry(ThreadLocal<?> key) { 
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }
    
        /** * Set the value associated with key. * * @param key the thread local object * @param value the value to be set */
        private void set(ThreadLocal<?> key, Object value) { 
    
            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.
    
            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)]) { 
                ThreadLocal<?> k = e.get();
    
                if (k == key) { 
                    e.value = value;
                    return;
                }
    
                if (k == null) { 
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
    
            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }
    }

## ThreadLocalMap的key（ThreadLocal对象）为什么用弱引用 ##

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，Entry的构造方法调用了父类WeakReference的构造方法，把k（ThreadLocal对象）传给了WeakReference的构造方法，WeakReference又调用了七父类Reference的构造方法，将k赋给了成员变量referent，也就是WeakReference关联了这个ThreadLocal对象，这里被关联的ThreadLocal对象就作为弱引用，这也就是弱引用对象的用法。那为什么要把k作为弱引用呢？**

**这个k是在Entry被引用的，Entry又是ThreadLocalMap的成员变量，也就是k被ThreadLocalMap引用（强引用），ThreadLocalMap是ThreadLocal的静态内部类，Thread类持有ThreadLocalMap类型的成员变量threadLocals（强引用），所以Thread对象不释放的情况下，即使我们不再使用 ThreadLocal对象了（就是k），将 k 置为 null，但k在线程的ThreadLocalMap里还有引用，导致其无法被GC回收（当然，可以等到线程运行结束后，整个Map都会被回收，但很多线程要运行很久（比如线程池的场景下，线程可能不会被释放，二是被放回池内供其他任务使用），如果等到线程结束，便会一直占着内存空间）。**

public class Thread implements Runnable {  
       ...
       ThreadLocal.ThreadLocalMap threadLocals = null;
       ...
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1dGlhbjcxMw_size_16_color_FFFFFF_t_70_pic_center]

**这里借用网上的图来说明一下ThreadLocal存在内存泄漏风险问题，从上图中可以看出，ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal不存在外部强引用时，Key(ThreadLocal)势必会被GC回收，这样就会导致ThreadLocalMap中key为null， 而value还存在着强引用（因为thread在），只有thead线程退出以后，value的强引用链条才会断掉。但如果当前线程再迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链：**

> Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value

**永远无法回收，造成内存泄漏。**

**这里的弱引用可以首先由 gc 来判断 ThreadLocal 实例（userInfoLocal）是否真的可以回收，由 gc 回收的结果，间接告诉我们，key 为 null 了，这时候 value 也可以被清理了，所以，我们在使用完 ThreadLocal 变量时，尽量用threadLocal.remove()来清除，避免 threadLocal=null 的操作。 remove方法会调用Reference的clear方法将referent设置为null，然后调用expungeStaleEntry方法清除掉线程 threadLocalMap 里的 entry，算是彻底清除。**

## ThreadLocal最佳实践 ##

**内存泄漏应该只会存在于线程池数量较大且存储在ThreadLocal中的数据量较大时，但是手动调用 remove() 可以加快内存的释放，所以还是推荐手动调用的。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1dGlhbjcxMw_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/cb0aca69a6564ec49b25133e27911d81.png