ThreadLocal常用方法浅析、使用场景及注意事项

一码事

已于 2023-05-31 16:21:54 修改

阅读量3.3k

点赞数 2

分类专栏： Java基础文章标签： ThreadLocal 内存泄漏 ThreadLocalMap 变量绑定本地线程

于 2019-05-29 00:05:48 首次发布

本文链接：https://blog.csdn.net/qq_42742861/article/details/90649837

版权

Java基础专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1. ThreadLocal详解

JDK1.2版本起，Java就提供了java.lang.ThreadLocal，ThreadLocal为每个使用线程都提供独立的变量副本，可以做到线程间的数据隔离，每个线程都可以访问各自内部的副本变量。

线程上下文ThreadLocal又称为"线程保险箱"，ThreadLocal能够将指定的变量和当前线程进行绑定，线程之间彼此隔离，持有不同的对象实例，从而避免了数据资源的竞争。

2. ThreadLocal的使用场景

在进行对象跨层传递的时候，可以考虑ThreadLocal，避免方法多次传递，打破层次间的约束。
线程间数据隔离。
进行事务操作，用于储存线程事务信息。

注意：
ThreadLocal并不是解决多线程下共享资源的一种技术，一般情况下，每一个线程的ThreadLocal存储的都是一个全新的对象(通过new关键字创建)，如果多线程的ThreadLocal存储了一个对象引用，那么就会面临资源竞争，数据不一致等并发问题。

3.常用方法源码解析

3.1 initialValue方法

 protected T initialValue() {
        return null;
 }

此方法为ThreadLocal保存的数据类型指定的一个初始化值，在ThreadLocal中默认返回null。但可以重写initialValue()方法进行数据初始化。
如果使用的是Java8提供的Supplier函数接口更加简化：

// withInitial()实际是创建了一个ThreadLocal的子类SuppliedThreadLocal，重写initialValue()
ThreadLocal<Object> threadLocal = ThreadLocal.withInitial(Object::new);

3.2 set(T value)方法

主要存储指定数据。

public void set(T value) {
    //	获取当前线程Thread.currentThread() 
    Thread t = Thread.currentThread();
    // 根据当前线程获取与之关联的ThreadLocalMap数据结构
    ThreadLocalMap map = getMap(t);
    if (map != null)
        // 核心方法。set 遍历整个Entry的过程，后面有详解
        map.set(this, value);
    else {
        // 调用createMap(),创建ThreadLocalMap,key为当前ThreadLocal实例，存入数据为当前value。
        // ThreadLocal会创建一个默认长度为16Entry节点，并将k-v放入i位置(i位置计算方式和hashmap相似，
        // 当前线程的hashCode&(entry默认长度-1)),并设置阈值(默认为0)为Entry默认长度的2/3。
        createMap(t, value);
    }
}

// set 遍历整个Entry的过程
private void set(ThreadLocal<?> key, Object value) {
   	// 获取所有的Entry
    Entry[] tab = table;
    int len = tab.length;
    // 根据ThreadLocal对象，计算角标位置。其中key.threadLocalHashCode获取ThreadLocal的hash值。引入了一个HASH_INCREMENT = 0x61c88647 斐波那契数列，使得hash值更加散列。
    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;
        }
		// 如果ThreadLocal为null，直接驱出并使用新数据(Value)占居原来位置，
		// 这个过程主要是防止内存泄漏。
        if (k == null) {
            // 驱除ThreadLocal为null的Entry，并放入Value，这也是内存泄漏的重点地区
            replaceStaleEntry(key, value, i);
            return;
        }
    }
	// entry都为null，创建新的entry，已ThreadLocal为key，将存放数据为Value。
    tab[i] = new Entry(key, value);
    int sz = ++size;
    // ThreadLoaclMapde的当前数据元素的个数和阈值比较，再次进行key为null的清理工作。
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        // 整理Entry，当Entry中的ThreadLocal对象为null时，通过重新计算角标位来清理
        // 以前ThreadLocal。如果Entry数量大于3/4容量进行扩容
        rehash();
}

 private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                                   int staleSlot) {
        Entry[] tab = table;
        int len = tab.length;
        Entry e;
		//向前扫描，查找最前一个无效的slot
        int slotToExpunge = staleSlot;
        for (int i = prevIndex(staleSlot, len);
             (e = tab[i]) != null;
             i = prevIndex(i, len))
            if (e.get() == null)
		//通过循环遍历，可以定位到最前面一个无效的slot
                slotToExpunge = i;
		//从i开始往后一直遍历到数组最后一个Entry（线性探索）
        for (int i = nextIndex(staleSlot, len);
             (e = tab[i]) != null;
             i = nextIndex(i, len)) {
            ThreadLocal<?> k = e.get();
			//找到匹配的key以后
            if (k == key) {
                // 0x61c88647 斐波那契数列
                e.value = value;//更新对应slot的value值
				//与无效的sloat进行交换
                tab[i] = tab[staleSlot];
                tab[staleSlot] = e;
				//如果最早的一个无效的slot和当前的staleSlot相等，则从i作为清理的起点
                if (slotToExpunge == staleSlot)
                    slotToExpunge = i;
					//从slotToExpunge开始做一次连续的清理
                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                return;
            }
			//如果当前的slot已经无效，并且向前扫描过程中没有无效slot，则更新slotToExpunge为当前位置
            if (k == null && slotToExpunge == staleSlot)
                slotToExpunge = i;
        }
		//如果key对应的value在entry中不存在，则直接放一个新的entry
        tab[staleSlot].value = null;
        tab[staleSlot] = new Entry(key, value);
		//如果有任何一个无效的slot，则做一次清理
        if (slotToExpunge != staleSlot)
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
    }

3.3 get方法

get()用于返回当前线程ThreadLocal中数据备份，当前线程的数据都存在一个ThreadLocalMap的数据结构中。

public T get() {
    Thread t = Thread.currentThread();
    // 获得ThreadLocalMap对象map，ThreadLocalMap是和当前Thread关联的，
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        // 存入ThreadLocal中的数据实际上是存储在ThreadLocalMap的Entry中。
        // 而此Entry是放在一个Entry数组里面的。
        // 获取当前ThreadLocal对应的entry
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            // 直接返回当前数据 
            T result = (T)e.value;
            return result;
        }
    }
    // ThreadLocalMap未初始化，首先初始化
    return setInitialValue();
}

// ThreadLocal的setInitialValue方法源码
private T setInitialValue() {
    // 为ThreadLocalMap指定Value的初始化值
    T value = initialValue();
    Thread t = Thread.currentThread();
    //	根据本地线程Thread获取ThreadLocalMap，一下方法与Set方法相同。
    ThreadLocalMap map = getMap(t);
    if (map != null)
        // 如果map存在，直接调用set()方法进行赋值。
        map.set(this, value);
    else
        // map==null；创建ThreadLocalMap对象，并将Thread和value关联起来
        createMap(t, value);
    return value;
}

3.4 小结

initialValue() : 初始化ThreadLocal中的value属性值。
set()：获取当前线程，根据当前线程从ThreadLocals中获取ThreadLocalMap数据结构，
- 如果ThreadLocalmap的数据结构没创建，则创建ThreadLocalMap,key为当前ThreadLocal实例，存入数据为当前value。ThreadLocal会创建一个默认长度为16Entry节点，并将k-v放入i位置(i位置计算方式和hashmap相似，当前线程的hashCode&(entry默认长度-1)),并设置阈值(默认为0)为Entry默认长度的2/3。
- 如果ThreadLocalMap存在。就会遍历整个Map中的Entry节点，如果entry中的key和本线程ThreadLocal相同，将数据(value)直接覆盖，并返回。如果ThreadLoca为null，驱除ThreadLocal为null的Entry，并放入Value，这也是内存泄漏的重点地区。
get()
get()方法比较简单。就是根据Thread获取ThreadLocalMap。通过ThreadLocal来获得数据value。注意的是：如果ThreadLocalMap没有创建，直接进入创建过程。初始化ThreadLocalMap。并直接调用和set方法一样的方法。

3.4 ThreadLocalMap数据结构

set()还是get()方法都是避免不了和ThreadLocalMap和Entry打交道。ThreadLocalMap是一个类似于HashMap的一个数据结构(没有链表)，仅仅用于存放线程存放在ThreadLocal中的数据备份，ThreadLocalMap的所有方法对外部都是不可见的。既然是MAP多余的角标位置是为了方便多个ThreadLocal的存放。
其中提到的线性探测。是用来解决hash冲突的一种策略。它是一种开放寻址策略。JAVA1.8之前HashMap解决hash冲突也是开发寻址策略。具体为链表法。
大家应该都知道hash表，它是根据key进行直接访问的数据结构，也就是说我们可以通过hash函数把key映射到hash表中的一个位置来访问记录，从而加快查找的速度。存放记录的数据就是hash表（散列表）。
当我们针对一个key通过hash函数计算产生的一个位置，在hash表中已经被另外一个键值对占用时，那么线性探测就可以解决这个冲突，这里分两种情况。
1. 写入：查找hash表中离冲突单元最近的空闲单元，把新的键值插入到这个空闲单元
2. 查找：根据hash函数计算的一个位置处开始往后查找，指导找到与key对应的value或者找到空的
  单元。
ThreadLocalMap中用于存储数据的Entry，它是一个WeakReference类型的子类，之所以设计成WeakReference是为了能够是JVM发生gc，能够自动回收，防止内存溢出现象。

4. ThreadLocal的副作用

4.1 ThreadLocal引起脏数据

线程复用会产生脏数据。
由于结程池会重用 Thread 对象，那么与 Thread 绑定的类的静态属性 ThreadLocal 变量也会被重用。如果在实现的线程 run()方法体中不显式地调用 remove() 清理与线程相关的ThreadLocal 信息，那么如果下一个线程不调用set()设置初始值，就可能 get()到重用的线程信息，包括 ThreadLocal 所关联的线程对象的 value 值。

// java.lang.Thread#threadLocals

  /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
  ThreadLocal.ThreadLocalMap threadLocals = null;

4.2 ThreadLocal引起的内存泄漏

在上面提到ThreadLocalMap中存放的Entry是WeakReference的子类。所以在JVM触发GC(young gc，Full GC)时，都会导致Entry的回收

在get数据的时候，增加检查，清除已经被回收器回收的Entry（WeakReference可以自动回收）

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    ThreadLocal<?> k = e.get();
  ...
    if (k == null)
        // 清除 key 是 null 的Entry
        expungeStaleEntry(i);
  ...
 return null;
}

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;
            // 清除key==null 的Entry
            i = expungeStaleEntry(i);
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}
```

set数据时增加检查，删除已经被垃圾回收器清理的Entry，并将其移除

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;
            // 清除key==null 的Entry
            i = expungeStaleEntry(i);
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}

基于上面三点：ThreadLocal在一定程度上保证不会发生内存泄漏。但是Thread类中有ThreadlocalMap的引用，导致对象的可达性，故不能回收。

ThreadLocal被置为null清除了。但是通过ThreadLocalMap还是被Thread类引用。导致该数据是可达的。所以内存得不到释放，除非当前线程结束，Thread引用就会被垃圾回收器回收。如图所示
ThreadLocal对象的引用.jpg
ThreadLocal中的Ref对象为null时的引用链

5 ThreadLocal内存泄漏解决方案及remove方法源码解析

解决ThreadLocal内存泄漏的常用方法是：在使用完ThreadLocal之后，及时remove掉。

public void remove() {
    // 根据当前线程，获取ThreadLocalMap
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        // map不为null，执行remove操作
        m.remove(this);
}

// ThreadLocal 的remove()
private void remove(ThreadLocal<?> key) {
    // 获取存放key-value的数组。
    Entry[] tab = table;
    int len = tab.length;
    // 根据ThreadLocal的HashCode确定唯一的角标
    int i = key.threadLocalHashCode & (len-1);
    for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {
        if (e.get() == key) {
            // 如果和本ThreadLocal相同。将引用置null。
            e.clear();
            // 实行Enty和Entry.value置null。源码中 tab[staleSlot].value = null; tab[staleSlot] = null;
            expungeStaleEntry(i);
            return;
        }
    }
}

6.拓展 :解决hash冲突方法

链接法（Chaining）：使用链表或其他数据结构来存储冲突的元素，将它们链接在同一个槽上。主要用在哈希表（Hash Table）
开放寻址法（Open Addressing）：在哈希表中寻找下一个可用的槽来存储冲突的元素，可以使用线性探测、二次探测、双重哈希等探测序列。
再哈希法（Rehashing）：使用另一个哈希函数对关键字进行再哈希，以获得一个新的哈希值，并将元素存储到对应的新槽中。
建立更好的哈希函数：设计更好的哈希函数可以减少冲突的概率，例如使用更复杂的算法或增加哈希值的长度。
负载因子调整：调整哈希表的负载因子，即表中元素的数量与槽位总数的比值，以控制冲突的发生概率。
哈希桶扩容：当哈希表中的负载因子过高时，可以动态扩容哈希表的大小，以减少冲突的概率。
使用完全哈希函数（Perfect Hashing）：对于静态数据集，可以使用完全哈希函数来避免冲突，完全哈希函数可以确保没有冲突发生。

一码事

关注

2
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
ThreadLocal常用方法浅析、使用场景及注意事项

1. ThreadLocal详解JDK1.2版本起，Java就提供了java.lang.ThreadLocal，ThreadLocal为每个使用线程都提供独立的变量副本，可以做到线程间的数据隔离，每个线程都可以访问各自内部的副本变量。线程上下文ThreadLocal又称为"线程保险箱"，ThreadLocal能够将指定的变量和当前线程进行绑定，线程之间彼此隔离，持有不同的对象实例，从而避免了数...
复制链接

扫一扫

专栏目录