1、简介
因为面试多了，大家也知道了这个类，觉得它是线程备份；真的是这样吗？我想说是，但是需要你主动去存线程相关的备份，如果多个线程存的备份都是一个对象，还是会相互影响的，是不是有点惊讶？
如果对同一份资源，每个线程各玩各的，而且不会相互影响，这时你可以选择ThreadLocal，它具有线程隔离的特性；
2、源码解析
从源码可以看出：这个类只是一个数据维增加、删除、获取的入口，数据存储在Thread类中，具体操作细节由内部类ThreadLocalMap来维护
2.1 使用
- 使用构造器生成一个相关的ThreadLocal的对象
- 使用set方法设置要保存的线程对象
- 在需要使用的使用，通过get方法获取
代码大致如下：
ThreadLocal<String> str = new ThreadLocal<>();
str.set("hello");
str.get();
为什么要这样，我们对具体的方法分析
2.2 方法详解
get方法
public T get() {
Thread t = Thread.currentThread();
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();
}
- 获取线程对象中ThreadLocalMap成员变量
- 如果map不为空，通过当前对象为key值，获取结果；
- 如果map为空，或者获取的数据为空，进行初始化操作
setInitialValue初始化方法
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
- initialValue方法，可被继承，默认返回null
- 如果线程的ThreadLocalMap对象为空，则直接创建；
- 并添加当前对象为key值，null为结果的数据
所以，如果没有设置值，获取的就会是空，这也就是为何需要在获取前使用set方法的原因；而且set的对象，是你自己来区分的，你多个线程设置为一样，那么多个线程存的是一样，获取的肯定也是一样
set方法
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
方法和setInitialValue执行大同小异；只不过此方法值是开发者自己提供，而setInitialValue由默认实现提供
remove方法
在不需要使用的使用，删除缓存线程中的对象，防止内存泄漏；不用时及时清理，减少内存溢出
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
2.3 数据结构分析
采用hash算法+数组类来存储
构造器
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);
}
private ThreadLocalMap(ThreadLocalMap parentMap) {
Entry[] parentTable = parentMap.table;
int len = parentTable.length;
setThreshold(len);
table = new Entry[len];
for (int j = 0; j < len; j++) {
Entry e = parentTable[j];
if (e != null) {
@SuppressWarnings("unchecked")
ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
if (key != null) {
Object value = key.childValue(e.value);
Entry c = new Entry(key, value);
int h = key.threadLocalHashCode & (len - 1);
while (table[h] != null)
h = nextIndex(h, len);
table[h] = c;
size++;
}
}
}
}
- table为数据存储数组
- 默认容量为16
- 如果调用赋值构造函数时，ThreadLocal的childValue方法必须实现，不然直接抛出异常
- 添加数据时，查找数组中的位置，然后进行添加，并且size++
- hash值所在的位置如果为空，也就已经查到了
- 如果1中位置已经存在数据，则进行+1循环查找，找到位置数据为空结束；
set方法
private void set(ThreadLocal<?> key, Object value) {
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();
}
- 首先获取当前设置key的hash值
- 从hash值位置开始，直到一个存储的为空数据的位置结束；在寻找的过程中，可能直接结束
- 数组的key值和当前要加入的数据中key值完全一样，则把value值替换
- 数组的key值为空，则由replaceStaleEntry方法进行数据替换或者插入
- 如果未找到合适位置，则最近的一个空数据位置，作为新数据插入位置
- 如果未进行重排去除无效数据且数据个数超过容量的2/3，则rehash；rehash首先清理无效数据，然后才可能进行扩容
replaceStaleEntry方法
private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
int slotToExpunge = staleSlot;
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))
if (e.get() == null)
slotToExpunge = i;
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == key) {
e.value = value;
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
if (slotToExpunge == staleSlot)
slotToExpunge = i;
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
- 当前位置的数据向前查找，直到空数据位置结束，查找key为空的相对最远位置slotToExpunge
- 当前位置向后查找，直到空数据位置结束
- 如果查找到key值与参数key值一致，则把数据value赋值，并置换staleSlot和查找位置数据，重排数据，并返回
- 未找到，则可能改变slotToExpunge的值，并在staleSlot直接赋值新的key-value值对对象
- slotToExpunge != staleSlot 则删除key== null的位置数据，并重排数据
cleanSomeSlots方法
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;
i = expungeStaleEntry(i);
}
} while ( (n >>>= 1) != 0);
return removed;
}
重复数据个数的一半次数，进行数据清理，如果遇到数据不为空，key值为空，此位置数据置空，并重排
rehash方法
private void rehash() {
expungeStaleEntries();
if (size >= threshold - threshold / 4)
resize();
}
private void expungeStaleEntries() {
Entry[] tab = table;
int len = tab.length;
for (int j = 0; j < len; j++) {
Entry e = tab[j];
if (e != null && e.get() == null)
expungeStaleEntry(j);
}
}
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;
} else {
int h = k.threadLocalHashCode & (newLen - 1);
while (newTab[h] != null)
h = nextIndex(h, newLen);
newTab[h] = e;
count++;
}
}
}
setThreshold(newLen);
size = count;
table = newTab;
}
- 首先进行清理数据，数据不为空，key为空的位置数据置null，并重排
- 如果数据个数大于容量的0.75则扩容，扩容系数为2
get方法
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);
}
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;
}
- 通过hash找到位置
- 以hash位置，比对数据中的key是否一致，一致直接返回value
- 否则，从当前hash值开始，找到下一个空数据位置结束；中间会处理一下情况
- 如果索引位置的key值一样，则返回value值
- 如果索引位置key值为空，则当前索引位置数据置空，并重排数据（见expungeStaleEntry方法）
- 返回null
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;
}
}
}
- 通过hash找到初始位置
- 以这个位置开始，找到数组中key值与要求的一样的，轻轻触数据的key值，结束
expungeStaleEntry方法
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
Entry e;
int i;
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == 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;
}
- 数组当前位置置空
- 从当前位置下一个位置开始，直到遇到数组位置上数据为空结束，进行重新排位
- 当前位置的key为空，则位置数据置空，数据个数减1
- 位置数据key值不为空，重新以hash值开始寻找一个空位置
3、原理总结
- ThreadLocal使用时需要先设置之后才能取用
- 不用时需要进行删除
- hash值以自增0x61c88647计算，这个数是斐波那契散列乘数,它的优点是通过它散列(hash)出来的结果分布会比较均匀；线程存放的数据越少，则效果越好
- 数据存储采用hash开发寻址算法，超过2/3个数，进行清理无效数据并且hash重排，超过3/4则进行扩容
技术变化都很快，但基础技术、理论知识永远都是那些；作者希望在余后的生活中，对常用技术点进行基础知识分享；如果你觉得文章写的不错，请给与关注和点赞；如果文章存在错误，也请多多指教！
