ThreadLocal学习笔记

我从雅楠回来了
106 阅读7分钟
ThreadLocal的数据结构

​ Thread类有一个类型为ThreadLocal.ThreadLocalMap的实例变量threadLocals，也就是说每个线程有一个自己的ThreadLocalMap。

ThreadLocalMap有自己的独立实现，可以简单地将它的key视作ThreadLocal，value为代码中放入的值（实际上key并不是ThreadLocal本身，而是它的一个弱引用）。

每个线程在往ThreadLocal里放值的时候，都会往自己的ThreadLocalMap里存，读也是以ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离。

ThreadLocalMap有点类似HashMap的结构，只是HashMap是由数组+链表实现的，而ThreadLocalMap中并没有链表结构。

我们还要注意Entry， 它的key是ThreadLocal<?> k ，继承自WeakReference， 也就是我们常说的弱引用类型。

Java四种引用
  • 强引用：我们常常new出来的对象就是强引用类型，只要强引用存在，垃圾回收器将永远不会回收被引用的对象，哪怕内存不足的时候
  • 软引用：使用SoftReference修饰的对象被称为软引用，软引用指向的对象在内存要溢出的时候被回收
  • 弱引用：使用WeakReference修饰的对象被称为弱引用，只要发生垃圾回收，若这个对象只被弱引用指向，那么就会被回收
  • 虚引用：虚引用是最弱的引用，在 Java 中使用 PhantomReference 进行定义。虚引用中唯一的作用就是用队列接收对象即将死亡的通知
ThreadLocal Hash算法
public class ThreadLocal<T> {
    private final int threadLocalHashCode = nextHashCode();

    private static AtomicInteger nextHashCode = new AtomicInteger();

    private static final int HASH_INCREMENT = 0x61c88647;
    
    private static final int INITIAL_CAPACITY = 16;

    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }
    
    static class 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对象，这个ThreadLocal.nextHashCode 这个值就会增长 0x61c88647 。

这个值很特殊，它是斐波那契数 也叫 黄金分割数。hash增量为 这个数字，带来的好处就是 hash 分布非常均匀。

ThreadLocalMap.set()原理
  1. 通过hash计算后的槽位对应的Entry数据为空：

    ​ 数据直接放到该槽位

  2. 槽位数据不为空，key值与当前ThreadLocal通过hash计算获取的key值一致：

    ​ 直接更新该槽位数据

  3. 槽位数据不为空，key值与当前ThreadLocal通过hash计算获取的key值不一致，往后遍历在找到Entry为null的槽位之前，没有遇到key过期的Entry：

    ​ 遍历散列数组，线性往后查找，如果找到Entey为null的槽位，则将数据放入该槽位中，或者往后遍历过程中，遇到了key值相等的数据，直接更新槽位数据。

  4. 槽位数据不为空，往后遍历过程中，在找到Entry为null的槽位之前，遇到了key过期的Entry（比如在index=7的槽位Entry的key=null）:

    ​ 初始化探测式清理过期数据扫描开始的位置：slotToExpunge=staleSlot=7；散列数据下标为7的位置对应的Entry数据key=null，表明此数据key值已经被垃圾回收掉了，此时就会执行replaceStakeEntry()方法，该方法含义是替换过期数据的逻辑，以index=7为起点开始遍历，进行探测式数据清理工作。

    ​ 初始化探测式清理过期数据扫描的开始位置：slotToExpunge=staleSlot=7；以当前staleSlot开始向前迭代查找，找其他过期的数据，然后更新过期数据起始扫描下标slotToExpunge。for循环迭代，直到碰到Entry为null结束。slotToExpunge是用来判断当前过期槽位staleSlot之前是否还有过期元素。

    ​ 接着开始以staleSolt位置向后迭代，如果找到了相同key值的Entry数据，找到后更新Entry的值并且交换staleSolt元素的位置。更新Entry数据，然后开始进行过期Entry的清理工作。

    ​ 向后遍历过程中，如果没有找到相同key值的Entry数据，则创建新的Entry，替换table[stableSlot]，替换完成后开始过期元素清理工作。清理工作主要是有两个方法：expungeStaleEntry()和cleanSomeSlots()

    ​

ThreadLocalMap.set()源码
private void set(ThreadLocal<?> key, Object value) {
	//通过key计算在散列数组中的对应位置，然后以当前key对应的桶的位置向后查找，找到可以使用的桶
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);

	//遍历当前key值对应的桶中Entry数据，不为null时
    for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();
		//如果k=key，说明当前set操作是一个替换过程
        if (k == key) {
            e.value = value;
            return;
        }
		//当前桶位置的Entry是过期数据
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }
	//Entry数据为null时
    tab[i] = new Entry(key, value);
    int sz = ++size;
	//做一次启发式清理工作，清理散列数组中Entry的key过期的数据，如果清理工作完成后，未清理到任何数据，且size超过了阈值（数组长度的2/3），进行rehash()操作，rehash（）中会先进行一轮
	//探测式清理，清理过期key，清理完成后size>=threshold-threshold/4，就会执行真正的扩容逻辑
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

什么情况下桶才是可以使用的呢？

  1. k = key 说明是替换操作，可以使用
  2. 碰到一个过期的桶，执行替换逻辑，占用过期桶
  3. 查找过程中，碰到桶中Entry=null的情况，直接使用
replaceStaleEntry(),替换过期数据
private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0);
}

private static int prevIndex(int i, int len) {
    return ((i - 1 >= 0) ? i - 1 : len - 1);
}

private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                                       int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;
	//探测式清理过期数据的开始下标
    int slotToExpunge = staleSlot;
	//以当前的staleSlot开始，向前迭代查找，找到没有过期的数据,遇到null结束
    for (int i = prevIndex(staleSlot, len);(e = tab[i]) != null;i = prevIndex(i, len)){
		//如果找到过期的数据，则更新探测式清理过期数据的开始下标
        if (e.get() == null){
			slotToExpunge = i;
		}
	}
		
	//以当前staleSlot向后查找，遇到null结束
    for (int i = nextIndex(staleSlot, len);(e = tab[i]) != null;i = nextIndex(i, len)) {

        ThreadLocal<?> k = e.get();
		//替换逻辑，替换新数据并且交换当前staleSlot位置
        if (k == key) {
            e.value = value;
			//交换数据
            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;
			//一开始向前查找过期数据并未找到过期的Entry数据，向后查找也未找到过期数据，修改开始探测式清理过期数据的下标为当前循环的index值
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
			//进行启发式过期数据清理
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }
		//当前key是个过期数据，并且一开始向前查找数据并未发现过期的Entry，将下标改为当前index值
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);
	//开启清理数据
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
ThreadLocalMap过期key探测式清理流程

​ expungeStaleEntry(),遍历散列数组，从开始位置向后探测清理过期数据，将过期数据的Entry设置为null，沿途中碰到未过期的数据则将此数据rehash后重新在table数组中定位，如果定位的位置已经有了数据，则会将未过期的数据放到最靠近此位置的Entry=null的桶中。

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;
}
ThreadLocalMap扩容机制

​ 在ThreadLocalMap.set()方法的最后，如果执行完启发式清理工作后，未清理到任何数据，且当前散列数组中Entry的数量已经达到了列表的扩容阈值(len*2/3)，就开始执行rehash()逻辑

private void rehash() {
    expungeStaleEntries();
	//就是原长度的3/4时决定是否扩容
    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);
    }
}

首先进行探测式清理；

扩容后的tab的大小为oldLen * 2，然后遍历老的散列表，重新计算hash位置，然后放到新的tab数组中，如果出现hash冲突则往后寻找最近的entry为null的槽位，遍历完成之后，oldTab中所有的entry数据都已经放入到新的tab中了。重新计算tab下次扩容的阈值

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;
}
ThreadLocalMap.get()详解

  1. 通过查找key值计算出散列表中slot位置，然后该slot位置中的Entry.key和查找的key一致，则直接返回

  2. slot位置中的Entry.key和查找的key不一致：

    ​ 向后查找，遇到为null的数据，进行探测式数据回收。直到找到key值相同的槽位，如果一直到了entry=null会停止，表明没有此数据

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;
}
ThreadLocalMap过期key启发式清理流程
avatar
文章
阅读
粉丝