ThreadLocal在平时开发中是用的比较多的一个类，主要用于存储线程的数据。下面我对ThreadLocal进行一下总结;
dreamcatcher-cx大佬对ThreadLocal的设计总结，写的比较深刻，很有帮助。
主要使用场景：
-
多数据源切换，记录当前线程访问的数据源
-
spring框架事务管理，用于存放事务数据；
-
springsecurity安全框架，用于存储用户登录信息；
除了以上还有很多，不限于以上。
解读源码
数据存储ThreadLockMap
-
通过Entry数组进行存储的；
-
Entry继承Reference类，是弱关联的类,当ThreadLocal的实例为空时，GC会快速收回；一般用于处理数据量较大且维持时间较短的业务。
-
Entry节点存储的是ThreadLocal对象和对象值
//是通过Entry数组进行存储的
private Entry[] table;
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
set 方法
-
存放ThreadLocal<?>的是弱关联的容器，GC会等存储满的时候处理；
-
存放的过程中，会对key判断，调整数组位置；
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);//获取存放的位置
/**
* 当i位置刚好已经存储了数据
*/
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {//向i+1<len遍历
ThreadLocal<?> k = e.get();//获取存入的ThreadLock
if (k == key) {//判断是否一致，如果一致，替换值并返回
e.value = value;
return;
}
if (k == null) {//如果i节点获取到的ThreadLocal为空的话
replaceStaleEntry(key, value, i);
return;
}
}
//没有存储数据的情况
tab[i] = new Entry(key, value);//新增信的节点
int sz = ++size;
/**
* 判断是不是要进行扩容
* Entry数组的扩容是2倍扩容的；
*/
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
// 判断i之前的非空节点的位置
int slotToExpunge = staleSlot;
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))
if (e.get() == null)
slotToExpunge = i;
//从staleSlot又向后循环，找到非空节点，查看是否又相同key
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
/**
* 判断和查询的实例是否同一个，如果key相同，则和staleSlot节点进行替换位置
*/
if (k == key) {
e.value = value;
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
if (slotToExpunge == staleSlot)
slotToExpunge = i;
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);//这里进行rehash
return;
}
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
// 如果key没找到那就在staleSlot位置插入一个新节点
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
// 判断是不是要重新尽心hash
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
get方法
- 获取存储的Entry节点
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
/**
* 从i位置往后逐个遍历查找如果找到了就返回，没找到返回null;
*/
return getEntryAfterMiss(key, i, e);
}
remove方法
- 查找对应数据节点进行删除就行
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方法数据存储
-
首次存储，新建一个ThreadLockMap,以当前ThreaLock为key;
-
如果线程的存储区域已经初始化过，则更新存储区域中的数据；
public void set(T value) {
Thread t = Thread.currentThread();// 获取当前线程
ThreadLocalMap map = getMap(t);//获取存储数据的MAP
if (map != null)//判断存储数据的map是否为空，如果为空则创建map,如果不为空，则存入数据
map.set(this, value);
else
createMap(t, value);//如果没有就创建一个，当前Thread
}
//获取当前线程的值存储区域
ThreadLocalMap getMap(Thread t) {
return t.threadLocals; //线程的成员变量
}
//给当前线程创建一个新的ThreadLocalMap,并存储以当前ThreaLocal实例为key的键值对。
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
get方法
-
如果在访问之前没有存储任何数据，则对ThreadLockMap进行初始化，绑定当前线程。并进行初始值的创建，和当前ThreadLock实例进行绑定，kv存储
-
如果获取到之前存储的值，则进行返回存入的值；
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);//获取当前线程的存储map
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);//获取当前的ThreadLock的节点，具体上面有介绍
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();//如果不存在则进行初始化
}
//进行一些初始化操作
private T setInitialValue() {
T value = initialValue();//ThreaLock提供的一个可继承的方法，进行初始化操作
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);//获取当前线程的
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
remove 方法
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)//在存储的map不为空的情况下，移除当前ThreadLock实例
m.remove(this);
}
总结
注意点：
1. ThreadLocalMap存储的key值为当前的ThreadLocal实例，所以一般要求ThreadLocal是单例的
2. 单个线程可以有多个ThreadLocal实例，存储数据。
总结分析：
1.ThreadLocal的设计思路：
-
原理：相当给当前线程的创建独有数据域，方便当前线程访问。这样避免了多线程环境中，访问当前线程锁的相关问题
-
之所以使用ThreadLocalMap进行存储，而不用HashMap，上面源码分析说了，源于Reference类的特性。
-
弱引用，当对象无用的时候，会快速被GC回收。符合线程的特点，一般一个线程时间不会很长，当伴随大量数据时能快速回收
-
当前线程结束的时候，要通过调用ThreadLocal的remove方法，及时将ThreadLocalMap中的对应实例key设置为空，方便GC快速回收
-
-
ThreadLocal操作更有优势，下面我具体分析以下
为什么用ThreadLocal类直接操作存储数据 ？
1.简化代码：
试想一下上面的源码，如果直接从Thread中存放数据，
首先，要用Thread.currentThread()获取当前线程，
然后，再通过当前线程thread获取存储的Map
再根据key获取对那个的操作
从上面的源码可以看出，这些操作细节，都已经在ThreadLocal类中进行了隐藏；
1.避免每次使用时的重复代码；
2.而使用ThreadLocal实例获取数据，相当于拿key直接获取数据，隐藏了获取细节
2.限制和统一管理存储值
1. 内部的Entry数组，进行了泛型约束，避免了直接在Thread类中Map操作key的不规范性；
2. 避免了开发人员直接操作当前线程，而使用“变量副本”进行操作