ThreadLocal
ThreadLocal实际上一种线程隔离机制，为了保证在多线程环境下对于共享变量的访问的安全性。
static ThreadLocal<Integer> local = new ThreadLocal<Integer>(){
protected Integer initialValue(){
return 0; //初始化一个值
}
};
public static void main(String[] args) {
Thread[] thread = new Thread[5];
for (int i = 0;i < 5;i++){
thread[i] = new Thread(()->{
int num = local.get(); //获得的值都是0 local.set(num+=5); //设置到local中
System.out.println(Thread.currentThread().getName()+"-"+num); });
}
for (int i = 0; i < 5; i++) {
thread[i].start();
}
}
ThreadLocal原理分析
主要API有 get()、set()、remove(),下面主要分析set()方法，get()和remove()实现相对简单。
1.png
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);
}
从ThreadLocalMap map = getMap(t);可以看到，线程内部维护了一个ThreadLocalMap,接下来我们去分析getMap(t)。
/**
/* ThreadLocal values pertaining to this thread. This map is maintained by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
* Get the map associated with a ThreadLocal. Overridden in
* InheritableThreadLocal.
*
* @param t the current thread
* @return the map
*/
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
getMap()操作就是返回ThreadLocal的一个 成员变量，换句话说就是这个ThreadLocalMap是线程私有的。因为第一次进来这个map是null，我们下一步是createMap(t, value);
/**
* Create the map associated with a ThreadLocal. Overridden in
* InheritableThreadLocal.
*
* @param t the current thread
* @param firstValue value for the initial entry of the map
*/
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
/**
* The table, resized as necessary.
* table.length MUST always be a power of two.
*/
private Entry[] table;
/**
* The initial capacity -- MUST be a power of two.
*/
private static final int INITIAL_CAPACITY = 16;
/**
* Construct a new map initially containing (firstKey, firstValue).
* ThreadLocalMaps are constructed lazily, so we only create
* one when we have at least one entry to put in it.
*/
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);
}
上述源码可以清楚的看到:
- 我们会初始化一个大小为
16的Entry数组，然后会生成一个数组下标，将数据放入。这里我们也可以猜想Entry的数据结构是key-value。 - 到这为止，我们已经初始化了一个entry数组，并且将我们要存放的值放入了
entry中，key表示的是当前线程，value是存放的值（num）， - 看到这里，你可能会有疑问，
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);，生成的数组下标会不会出现重复，也就是我们常说的hash冲突,我们可以看一下他取的hash值是什么。
5.png
/**
* ThreadLocals rely on per-thread linear-probe hash maps attached
* to each thread (Thread.threadLocals and
* inheritableThreadLocals). The ThreadLocal objects act as keys,
* searched via threadLocalHashCode. This is a custom hash code
* (useful only within ThreadLocalMaps) that eliminates collisions
* in the common case where consecutively constructed ThreadLocals
* are used by the same threads, while remaining well-behaved in
* less common cases.
*/
private final int threadLocalHashCode = nextHashCode();
/**
* Returns the next hash code.
*/
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
/**
* 连续生成的散列码之间的差异
* 隐式顺序线程将局部IDs转换为近似最优分布
* 两个表的幂的乘法散列值。
*/
private static final int HASH_INCREMENT = 0x61c88647;
我简单的翻译了一下，核心思想就是通过散列（斐波那契数列）的方式避免hash冲突，大家可以通过拿到这个hash值，自己测试一下他生成的值的分布。
public class HashDemo {
private static final int HASH_INCREMENT = 0x61c88647;
public static void main(String[] args) {
magicHash(16);
magicHash(32);
}
private static void magicHash(int size){
int hashCode=0;
for(int i=0;i<size;i++){
hashCode=i*HASH_INCREMENT+HASH_INCREMENT;
System.out.print((hashCode&(size-1))+" ");
}
System.out.println("");
}
}
上述代码运行的结果：
2.png
set方法最终实现
前面分析了set方法第一次初始化ThreadLocalMap的过程，也对ThreadLocalMap的结构有了一个全面的了解。那么接下来看一下map不为空时的执行逻辑
- 根据key的散列哈希计算Entry的数组下标
- 通过线性探索探测从i开始往后一直遍历到数组的最后一个Entry
- 如果map中的key和传入的key相等，表示该数据已经存在，直接覆盖
- 如果map中的key为空，则用新的key、value覆盖，并清理key=null的数据
- rehash扩容
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
// 根据哈希码和数组长度求元素放置的位置，即数组下标
int i = key.threadLocalHashCode & (len-1);
//从i开始往后一直遍历到数组最后一个Entry(线性探索)
for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get(); //如果key相等，覆盖value
if (k == key) {
e.value = value;
return;
}
//如果key为null,用新key、value覆盖，同时清理历史key=null的陈旧数据(弱引用)
if (k == null) {
replaceStaleEntry(key, value, i); return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
//如果超过阀值，就需要扩容了
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
线性探测，是用来解决hash冲突的一种策略。它是一种开放寻址策略
我想大家应该都知道hash表，它是根据key进行直接访问的数据结构，也就是说我们可以通过hash函数把key映射到hash表中的一个位置来访问记录，从而加快查找的速度。存放记录的数据就是hash表（散列表）
当我们针对一个key通过hash函数计算产生的一个位置，在hash表中已经被另外一个键值对占用时，那么线性探测就可以解决这个冲突，这里分两种情况。
写入： 查找hash表中离冲突单元最近的空闲单元，把新的键值插入到这个空闲单元
查找： 根据hash函数计算的一个位置处开始往后查找，指导找到与key对应的value或者找到空的单元。
replaceStaleEntry
接下来分析一下清理的过程和替换过程，这个过程比较有意思。从名字上来看，叫替换脏的不干净的Entry，我们来看是怎么实现的。
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) {
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);
}
}
线性探测
用来解决hash冲突的一种策略.
- 写入 , 找到发生冲突最近的空闲单元
- 查找, 从发生冲突的位置，往后查找
