一:简述
我们很多时候为了实现数据在线程级别下的隔离,会使用到ThreadLocal,那么TheadLocal是如何实现数据隔离的呢?今天就和大家一起分析一下ThreadLocal的实现原理。
二:TheadLocal的原理分析
1.ThreadLocal的存储结构
每个Thread对象中都有一个threadLocals成员变量,threadLocals是一个类型为ThreadLocalMap的map,而ThreadLocal正是基于这个map来实现线程级别的数据隔离的。
我们先看ThreadLocalMap的成员变量
//默认的初始化容量大小 private static final int INITIAL_CAPACITY = 16; //Entry数组 真正存储的数据结构 private Entry[] table; //记录当前元素的数量 private int size = 0; //扩容的阈值 private int threshold;
Entry数组是真正存储数据的地方,可以看出Entry是一个key-value的存储结构,以当前ThreadLocal对象的引用作为key,存储的值为value。Entry继承了WeakReference,并且在构造函数的时候,调用super(k)(也就是WeakReference的构造函数)来对key进行初始化,所以Entry的key是一个弱引用。
static class Entry extends WeakReference> { /** The value associated with this ThreadLocal. */ Object value; Entry(ThreadLocal> k, Object v) { super(k); value = v; } }
根据上面的分析,我们可以知道ThreadLocal的存储结构大概是这样的:
2.源码分析
接下来我们从ThreadLocal的set(),get(),remove()方法为入口对ThreadLocal的源码进行分析。
set()方法
首先判断当前线程的threadLocals是否初始化,如果没有初始化,那么调用createMap()方法进行初始化并设置值,否则调用ThreadLocalMap的set()方法设置值。
流程图:
三:源码分析
public void set(T value) { //利用当前线程获取它的threadLocals(threadLocals是一个ThreadLocalMap) Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); //如果已经初始化 那么就调用ThreadLocalMap的set()方法 if (map != null) map.set(this, value); else // 没有初始化 先进行初始化 createMap(t, value); }
ThreadLocalMap getMap(Thread t) { //返回当前线程的threadLocals return t.threadLocals; }
createMap()
createMap()会调用ThreadLocalMap的构造函数对当前线程的threadLocals初始化,并且初始化Entry数组,然后利用hash算法计算出数组下标,将需要set的值存储在Entry数组。
void createMap(Thread t, T firstValue) { t.threadLocals = new ThreadLocalMap(this, 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); }
如果threadLocals已经初始化,直接调用ThreadLocalMap的set(),接下来看ThreadLocalMap的set()方法。
首先利用hash算法计算数组下标,如果计算出的位置没有值,直接将值设置进去,如果存在值(出现hash冲突),分为三种情况:
1.如果key相同,那么直接覆盖值
2.如果计算出的位置的Entry的key为null,那么说明是无效的数据(key为null,entry不为null),为了避免内存泄漏需要清除这种数据。所以调用replaceStaleEntry()方法将无效数据清除并且将需要设置的值设置到Entry数组中。
3.如果key不相同,而且计算出的位置的Entry的key不为null,那么进入到下一次for循环将计算出的下标+1,(如果到达下标最大值,则设置为0),利用新的位置重新进行判断,直到获取到一个合法的位置(线性寻址法解决hash冲突的问题)。
注:这里大家可以评论区讨论下为什么不和HashMap那样利用链表法解决hash冲突。我个人的看法是因为ThreadLocal的数据量不会向HashMap那么多,所以不需要利用链表和红黑树来解决hash冲突,链表法解决代码相对比较复杂而且扩容迁移数据的数据会比较麻烦。
源码:
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); //如果出现hash冲突会进入for循环 for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) { ThreadLocal> k = e.get(); //如果key相同 那么直接将值覆盖 if (k == key) { e.value = value; return; } //如果key为null 那么说明是无效的数据 需要进行清除 if (k == null) { //调用replaceStaleEntry()方法进行清除数据 并设置值 replaceStaleEntry(key, value, i); return; } } //如果没有hash冲突 直接赋值到对应下标的位置 tab[i] = new Entry(key, value); // 将当前元素个数+1 int sz = ++size; //如果没有需要清除的元素,并且当前元素个数已经达到扩容的阈值,那么进行扩容 if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash(); }
接下来看replaceStaleEntry(),看ThreadLocal是如何清除无效的数据的。
当前节点是无效的数据,那么周围也可能存在无效的数据,所以ThreadLocal在清除无效的数据时,会顺便清除周围的连续的无效数据,先利用for循环从当前节点向前遍历,调整slotToExpunge的值(slotToExpunge 用于保存开始清除无效数据的下标位置), 然后向后遍历,如果有entry的key和需要存放的数据的key相同,那么直接覆盖值,并且交换当前节点和新设置的entry的值。
流程图:
private void replaceStaleEntry(ThreadLocal> key, Object value, int staleSlot) { Entry[] tab = table; int len = tab.length; Entry e; // slotToExpunge 用于保存开始清除无效数据的下标位置 int slotToExpunge = staleSlot; //从当前位置向前遍历,直到找到一个有效数据的下标 for (int i = prevIndex(staleSlot, len); (e = tab[i]) != null; i = prevIndex(i, len)) //e.get()返回Entry的key,威null代表是无效数据 //(因为只有entry不为null才会进入for循环) 所以key为null,就是无效数据 //for循环将清除无效数据的下标往前挪 if (e.get() == null) slotToExpunge = i; //从当前位置往后遍历 for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) { ThreadLocal> k = e.get(); //如果遍历的是否发现有和当前Entry相同的key的entry,那么交换两者的位置 if (k == key) { e.value = value; tab[i] = tab[staleSlot]; tab[staleSlot] = e; //如果slotToExpunge和staleSlot相等 //证明当前节点的前面没有和当前节点连续的无效数据 //所以从交换完的位置开始清除无效数据 调用cleanSomeSlots()方法和expungeStaleEntry()方法清除无效数据 清除完返回。 if (slotToExpunge == staleSlot) slotToExpunge = i; cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); return; } //如果key为null 而且当前entry之前没有与当前节点连续的无效数据 //刷新开始清除无效数据的下标 if (k == null && slotToExpunge == staleSlot) slotToExpunge = i; } // If key not found, put new entry in stale slot //如果没有找到连续的无效数据 把当前的节点的value重置为null 并且将新的值赋值到当前位置 //因为当前的entry是无效的数据 tab[staleSlot].value = null; tab[staleSlot] = new Entry(key, value); // If there are any other stale entries in run, expunge them //如果slotToExpunge 和 staleSlot不相等 说明有连续的无效数据需要顺便清除 if (slotToExpunge != staleSlot) cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); }
注:大家可以在评论区讨论一下,这里为什么要交换一下数据,我个人认为,第一是为了保证数据存储的位置尽可能的在hash计算出位置,有利于后续的get()方法,第二:交换位置之后有利于让无效的数据连续起来,提高清除无效数据的效率。
真正清除无效数据的方法是expungeStaleEntry()方法和cleanSomeSlots()方法
我们先看expungeStaleEntry()方法
expungeStaleEntry()
expungeStaleEntry()方法从当前节点开始向后遍历(直到遇到enrty为null的节点),将无效数据清除,并且重新计算有效的entry的数组下标,如果计算出的下标和entry的下标不相同(这是因为采用了线性寻址法,所以hash计算出下标可能和实际的下标不一样),重新找到合适的位置。
private int expungeStaleEntry(int staleSlot) { Entry[] tab = table; int len = tab.length; // expunge entry at staleSlot //先将当前节点清除 tab[staleSlot].value = null; tab[staleSlot] = null; size--; // Rehash until we encounter null Entry e; int i; for (i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) { ThreadLocal> k = e.get(); if (k == null) { //key为null 证明是无效数据 清除 e.value = null; tab[i] = null; size--; } else { //重新计算数组下标 如果数组下标发生变化 那么将数据迁移到新的位置上 int h = k.threadLocalHashCode & (len - 1); if (h != i) { tab[i] = null; //重新利用线性寻址法寻找合适的下标位置 while (tab[h] != null) h = nextIndex(h, len); tab[h] = e; } } } return i; }
然后是cleanSomeSlots()方法
cleanSomeSlots()
调用log(n)次expungeStaleEntry()方法进行清除无效数据。这个官方说不调用n次来清除,为了效率,而且经过测试调用log(n)次清除无效的数据的效果已经很好了。(n代表entry数组的长度)。
private boolean cleanSomeSlots(int i, int n) { //removed 是否清除了数据的标记 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; i = expungeStaleEntry(i); } } while ( (n >>>= 1) != 0); return removed; }
如果set()方法设置值之后,需要扩容会调用rehash()方法进行扩容。
先调用expungeStaleEntries()清除一下数据,如果还是需要扩容,那么调用resize()进行扩容。
rehash()
private void rehash() { //再试清除一下数据 expungeStaleEntries(); // Use lower threshold for doubling to avoid hysteresis //如果还是需要扩容 那么会调用 resize()进行扩容 if (size >= threshold - threshold / 4) resize(); }
resize()
resize()方法会创建一个容量为原来两倍的数组,并且将数据迁移到新的数组上面,将新的数组赋值给table变量。(扩容方法比较简单)
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]; if (e != null) { ThreadLocal> k = e.get(); if (k == null) { e.value = null; // Help the GC } else { int h = k.threadLocalHashCode & (newLen - 1); //线性寻址法解决hash冲突 while (newTab[h] != null) h = nextIndex(h, newLen); newTab[h] = e; count++; } } } setThreshold(newLen); size = count; table = newTab; }
get()方法
获取到当前线程的threadLocals,如果threadLocals已经初始化,那么调用getEntry()方法获取值。否则调用setInitialValue()获取我们在initialValue()设置的初始化的值。
public T get() { Thread t = Thread.currentThread(); //利用当前线程获取它的threadLocals(threadLocals是一个ThreadLocalMap) ThreadLocalMap map = getMap(t); if (map != null) { ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) { @SuppressWarnings("unchecked") T result = (T)e.value; return result; } } return setInitialValue(); }
现在我们看getEntry()方法
如果找到key相同的Entry 直接返回,否则调用getEntryAfterMiss()方法
getEntry()
private Entry getEntry(ThreadLocal> key) { int i = key.threadLocalHashCode & (table.length - 1); Entry e = table[i]; //如果找到key相同的Entry 直接返回 if (e != null && e.get() == key) return e; else return getEntryAfterMiss(key, i, e); }
getEntryAfterMiss()
getEntryAfterMiss()从当前节点往后遍历查找,遍历找到key相同的entry,找到就返回,否则返回null,如果有无效数据,顺便清除一下。
private Entry getEntryAfterMiss(ThreadLocal> key, int i, Entry e) { Entry[] tab = table; int len = tab.length; while (e != null) { ThreadLocal> k = e.get(); //找到key相同的entry 直接返回 if (k == key) return e; if (k == null) //当前数据为无效数据 清除一下 expungeStaleEntry(i); else //否则向后继续查找 i = nextIndex(i, len); e = tab[i]; } return null; }
最后是remove()方法
remove()
利用hash算法计算下标,从下标位置开始往后遍历,找到key相同的entry,将entry删除,顺便调用expungeStaleEntry()方法清除一下无效的数据。
public void remove() { ThreadLocalMap m = getMap(Thread.currentThread()); if (m != null) m.remove(this); }
private void remove(ThreadLocal> key) { 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)]) { if (e.get() == key) { e.clear(); expungeStaleEntry(i); return; } } }
四:总结
本篇文章对ThreadLocal的数据存储结构,以及set(),get(),remove()方法进行了分析。最后给大家可以再讨论一个问题:为什么ThreadLocal的Entry的key要使用弱引用?
以上就是ThreadLocal数据存储结构原理解析的详细内容,更多关于ThreadLocal数据存储结构的资料请关注脚本之家其它相关文章!