多线程学习笔记九之ThreadLocal

时间:2023-03-08 16:19:07
多线程学习笔记九之ThreadLocal

多线程学习笔记九之ThreadLocal

简介

  ThreadLocal顾名思义理解为线程本地变量,这个变量只在这个线程内,对于其他的线程是隔离的,JDK中对ThreadLocal的介绍:

This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its{@code get} or {@code set} method) has its own, independently initialized copy of the variable. {@code ThreadLocal} instances are typically private static fields in classes that wish to associate state with a thread (e.g.,a user ID or Transaction ID).

大意是ThreadLocal提供了线程局部变量,只能通过ThreadLocal的set方法和get方法来存储和获得变量。

类结构

  ThreadLocal类结构如下:

多线程学习笔记九之ThreadLocal

可以看到ThreadLocal有内部类ThradLocalMap,ThreadLocal存储线程局部对象就是利用了ThreadLocalMap数据结构,在下面的源码分析也会先从这里开始。

源码分析

ThreadLocalMap

  ThreadLocalMap静态内部类Entry是存储键值对的基础,Entry类继承自WeakReference(为什么用弱引用在后面解释),通过Entry的构造方法表明键值对的键只能是ThreadLocal对象,值是Object类型,也就是我们存储的线程局部对象,通过super调用父类WeakReference构造函数将ThreadLocal<?>对象转换成弱引用对象

  ThreadMap存储键值对的原理与HashMap是类似的,HashMap依靠的是数组+红黑树数据结构和哈希值映射,ThreadMap依靠Entry数组+散列映射,ThreadLocalMap使用了Entry数组来保存键值对,Entry数组的初始长度为16,键值对到Entry数组的映射依靠的是int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);,通过ThreadLocal对象的threadLocalHashCode与(INITIAL_CAPACITY - 1)按位相与将键值对均匀散列到Entry数组上。

    static class ThreadLocalMap {

        // 键值对对象
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value; Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
} //初始Entry数组大小
private static final int INITIAL_CAPACITY = 16; //Entry数组
private Entry[] table; //ThreadLocalMap实际存储键值对的个数
private int size = 0; //数组扩容阈值
private int threshold; // Default to 0 //阈值为数组长度的2/3
private void setThreshold(int len) {
threshold = len * 2 / 3;
} 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对象,并把传入的第一个键值对存储
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);
} }

  ThreadLocal作为做为键值对的键通过常量threadLocalHashCode映射到Entry数组,threadLocalHashCode初始化时会调用nextHashCode()方法,就是在nextHashCode的基础上加上0x61c88647,实际上每个ThreadLocal对象的threadLocalHashCode值相差0x61c88647,这样生成出来的Hash值可以较为均匀的散列到2的幂次方长度的数组中,具体可见这篇文章为什么使用0x61c88647

  由于采用的是散列算法,就需要考虑Hash冲突的情况,HashMap解决Hash冲突的方法是链表+红黑树,ThreadLocalMap解决方法是linear-probe(线性探测),简单来说如果散列对应的位置已经有键值对占据了,就把散列位置加/减一找到符合条件的位置放置键值对。

    // final常量,一旦确定不再改变
private final int threadLocalHashCode = nextHashCode(); /**
* The next hash code to be given out. Updated atomically. Starts at
* zero.
*/
private static AtomicInteger nextHashCode =
new AtomicInteger(); /**
* The difference between successively generated hash codes - turns
* implicit sequential thread-local IDs into near-optimally spread
* multiplicative hash values for power-of-two-sized tables.
*/
private static final int HASH_INCREMENT = 0x61c88647; /**
* Returns the next hash code.
*/
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
} //构造方法
public ThreadLocal() {
}

set(T value)

  简要介绍完了内部类ThreadLocalMap后,set方法属于ThreadLocal,首先获得与线程Thread绑定的ThreadLocalMap对象,再将ThreadLocal和传入的value封装为Entry键值对存入ThreadLocalMap中。注意,ThreadLocalMap对象是在线程Thread中声明的:

ThreadLocal.ThreadLocalMap threadLocals = null;

    public void set(T value) {
//获得当前线程对象
Thread t = Thread.currentThread();
//获得线程对象的ThreadLocalMap
ThreadLocalMap map = getMap(t);
// 如果map存在,则将键值对存到map里面去
if (map != null)
map.set(this, value);
//如果不存在,调用ThreadLocalMap构造方法存储键值对
else
createMap(t, value);
} //返回线程t中声明的Thread
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
} void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
  • set(ThreadLocal<?> key, Object value)

      在ThreadLocalMap存在的情况下,调用ThreadLocal类的set方法存储键值对,set方法需要考虑散列的位置已经有键值对:如果已经存在的键值对的键当存入的键,覆盖键值对的值;如果键值对的键ThreadLocal对象已经被回收,调用replaceStaleEntry方法删除table中所有陈旧的元素(即entry的引用为null)并插入新元素。
    private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
//利用ThreadLocal的threadLocalHahsCode值散列
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对象被回收,用新的键值对代替过时的键值对
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
} //散列位置为空,直接存储键值对
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}

get()

  获得当前线程中保存的以ThreadLocal对象为键的键值对的值。首先获取当前线程关联的ThreadLocalMap,再获得以当前ThreadLocal对象为键的键值对,map为空的话返回初始值null,即线程局部变量为null,

    public T get() {
//获取与当前线程绑定的ThreadLocalMap
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
//map不为空,获取键值对对象
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
} private Entry getEntry(ThreadLocal<?> key) {
//散列
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
//判断散列位置的键值对是否符合条件:e.get()==key
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);
} //线性探测寻找key对应的键值对
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length; while (e != null) {
ThreadLocal<?> k = e.get();
if (k == key)
return e;
if (k == null)
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}

remove()

  从ThreadLocalMap中移除键值对,一般在get方法取出保存的线程局部变量后调用remove方法防止内存泄露。

    public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}

为什么ThreadLocalMap的键是WeakReferrence?

  键值对对象Enry的键是ThreadLocal对象,但是使用WeakReferrence虚引用包装了的,虚引用相对于我们经常使用的String str = "abc"这种强引用来说对GC回收对象的影响较小,以下是虚引用的介绍:

WeakReference是Java语言规范中为了区别直接的对象引用(程序中通过构造函数声明出来的对象引用)而定义的另外一种引用关系。WeakReference标志性的特点是:reference实例不会影响到被应用对象的GC回收行为(即只要对象被除WeakReference对象之外所有的对象解除引用后,该对象便可以被GC回收),只不过在被对象回收之后,reference实例想获得被应用的对象时程序会返回null。

  如果Entry的键使用强引用,那么我们存入的键值对即使线程之后不再使用也不会被回收,生命周期将变得和线程的生命周期一样。而使用了虚引用之后,作为键的虚引用并不影响ThreadLocal对象被GC回收,当ThreadLocal对象被回收后,键值对就会被标记为stale entry(过期的键值对),再下一次调用set/get/remove方法后会进行  ThreadLocalMap层面对过期键值对进行回收,防止发生内存泄漏。

注意:当我们使用了set方法存入局部变量后,如果不进行get/remove,那么过期的键值对无法被回收,所以建议在get取出存储变量后手动remove,可以有效防止内存泄漏。

总结

  ThreadLocal实现了存储线程局部变量,ThreadLocal的实现并不是HashMap<Thread,Object>以线程对象为键,而是在线程内部关联了一个ThreadLocalMap用于存储键值对,键值对的键是ThreadLocal对象,所以ThreadLocal对象本身是不存储内容的,而是作为键与存储内容构成键值对。