ThreadLocal#ThreadLocalMap内部类实现细节

文章目录

    • 一、ThreadLocalMap实现思想
    • 二、属性与构造方法
    • 三、核心方法
      • 3.1 hashcode的计算
      • 3.2 set()方法
      • 3.3 getEntry()方法
      • 3.4 remove()方法
      • 3.5 rehash()方法
      • 3.6 对于清理过期数据的关键实现方法
        • 1. replaceStaleEntry()方法
        • 2. cleanSomeSlots方法
        • 3. expungeStaleEntry(int staleSlot) 方法

接上一篇 ThreadLocal源码分析。

一、ThreadLocalMap实现思想

ThreadLocal类图如下
ThreadLocal#ThreadLocalMap内部类实现细节_第1张图片
ThreadLocal是一种存储变量与线程绑定的方式,在每个线程中用自己的ThreadLocalMap安全隔离变量,实现线程封闭。

针对于ThreadLocal的底层实现原理,笔者在前一篇博客有详细的介绍,并对源代码中实现细节做了详尽的分析。快速搞懂ThreadLocal实现原理

ThreadLocalMap是ThreadLocal内的一个Map实现,没有实现任何接口,仅用于线程内部存储ThreadLocal变量值。

static class ThreadLocalMap {
      ... }

static class Entry extends WeakReference<ThreadLocal<?>> {
     
    Object value; // ThreadLocal变量值
    Entry(ThreadLocal<?> k, Object v) {
     
        super(k);
        value = v;
    }
}

底层是Entry数组,Entry的key为ThreadLocal,value是线程的该ThreadLocal变量值。Entry内部类继承了WeakReference类。当entry.get()方法得到的ThreadLocal引用为空,表示该key不再被引用,此时Entry对象视为【过期】,在数组中删除。

二、属性与构造方法

属性:

private Entry[] table; // 表,必须为2的幂次方大小
private int size = 0; // 初始Entry数
private int threshold; // resize操作,元素个数阈值
// 负载因子固定为2/3
private void setThreshold(int len) {
     
    threshold = len * 2 / 3;
}

构造方法:

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
     
    // 初始化大小为16的Entry数组
    table = new Entry[INITIAL_CAPACITY];
    // 取模对应数组索引
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    table[i] = new Entry(firstKey, firstValue); // 插入元素
    size = 1; // 更新size
    setThreshold(INITIAL_CAPACITY); // 设置resize阈值,此时为10
}

三、核心方法

3.1 hashcode的计算

ThreadLocal变量与当前线程绑定,在HashMap中作为key,通过threadLocalHashCode值来查找。

// 自定义hashcode,可以用来解决同一线程连续构造ThreadLocal对象引起的冲突。
private final int threadLocalHashCode = nextHashCode()

// 下一个hashCode值,原子更新,初始值为0
private static AtomicInteger nextHashCode = new AtomicInteger();

// 返回下一个hashcode
private static int nextHashCode() {
     
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

// 魔数:相邻两个hashcode之间的偏移
// 对2的幂次方大小的表,产生近似最优的hash值
private static final int HASH_INCREMENT = 0x61c88647;

3.2 set()方法

设置ThreadLocal变量值。

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; // entry不为空
         e = tab[i = nextIndex(i, len)]) {
     
        ThreadLocal<?> k = e.get(); // 获取Entry的key--ThreadLocal

        // 如果当前Entry的key与形参key相等,更新value值
        if (k == key) {
     
            e.value = value;
            return;
        }
        // 如果当前Entry的key为空,说明已过期,做清理!
        if (k == null) {
     
            // 清理过期Entry,继续探索放置位置
            replaceStaleEntry(key, value, i); 
            return;
        }
    }

    // 若没有找到对应key,则在空位置创建Entry
    tab[i] = new Entry(key, value);
    int sz = ++size; // 更新size
    // 清理一些过期的位置,判断是否需要扩容
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

从set方法中,可以看出ThreadLocalMap中哈希冲突解决方法是开放地址法,而不是HashMap等采用链地址法。
前后索引位置–循环

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);
}

3.3 getEntry()方法

根据ThreadLocal获取对应Entry对象。

private Entry getEntry(ThreadLocal<?> key) {
     
    // 根据hashcode计算直接hash索引
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    // 如果是找到并且是有效Entry对象,直接返回
    if (e != null && e.get() == key)
        return e;
    else // 不是目标Entry
        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) // 找到目标Entry
            return e;
        if (k == null) // 清理过期Entry
            expungeStaleEntry(i);
        else // 当前位置是有效Entry,索引右移
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null; // 找不到,返回null
}

3.4 remove()方法

移除ThreadLocal变量对应的Entry对象。

private void remove(ThreadLocal<?> key) {
     
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);
    // 遍历找到指定key的Entry对象
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
     
        if (e.get() == key) {
     
            e.clear(); // 清理引用
            expungeStaleEntry(i); // 清理过期Entry
            return;
        }
    }
}

3.5 rehash()方法

private void rehash() {
     
    // 清理table中所有过期Entry对象。
    expungeStaleEntries();

    // 如果元素个数超过阈值的3/4时,进行扩容
    // 注:阈值本身是数组长度的2/3
    if (size >= threshold - threshold / 4)
        resize();
}
// 扩容至原容量的2倍
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) {
      // 过期Entry,清空value
                e.value = null; // 利于垃圾回收
            } 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;
}

3.6 对于清理过期数据的关键实现方法

1. replaceStaleEntry()方法

清理过期Entry,设置输入键值对。

// staleSlot:key == null的位置
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                               int staleSlot) {
     
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    // 从前一个位置开始向前寻找过期Entry,直到entry不为空
    // 不断向前移动清理位置
    int slotToExpunge = staleSlot; // 清理元素的最开始位置
    for (int i = prevIndex(staleSlot, len); 
         (e = tab[i]) != null;  // entry不为空
         i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i; 

    // 从后一个位置向后探索
    for (int i = nextIndex(staleSlot, len);
         (e = tab[i]) != null; // entry不为空
         i = nextIndex(i, len)) {
     
        ThreadLocal<?> k = e.get();

        // 如果找到key,需要将它与过期位置元素做交换,来维持哈希表顺序。
        if (k == key) {
     
            e.value = value; // 更新value

            tab[i] = tab[staleSlot]; // 元素交换
            tab[staleSlot] = e; 

            // 如果相等,表示向前遍历时没有找到key为null的元素
            // 前面语句进行了元素交换,此时位置i之前的元素均不需要清理
            if (slotToExpunge == staleSlot)
                slotToExpunge = i; // 更新清理开始位置
            // 从slotToExpunge位置清理过期Entry(key == null)
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        // 如果遍历中找到key为null的元素,并且向前没有找到key为null的位置
        // 更新清理开始位置slotToExpunge为当前位置i
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // 如果没找到key,新建Entry发在staleSlot位置
    tab[staleSlot].value = null; // 清理动作
    tab[staleSlot] = new Entry(key, value);

    // 如果除了staleSlot位置,还有其他位置元素要清理(key == null的Entry)
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

【注】slotToExpunge变量记录着元素清理的最开始位置。

2. cleanSomeSlots方法

尝试扫描一些过期元素的位置,当添加新元素、清理其他过期元素时被调用。

从i位置开始扫描,i位置不是过期元素。而参数n用来限制扫描次数,如果过期Entry没有发现,可以扫描log(n)次,log(n)的设定出于性能的考虑。

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];
        // 遍历到key==null的Entry
        if (e != null && e.get() == null) {
     
            n = len; // 重置n
            removed = true; // 标志有清理元素
            i = expungeStaleEntry(i); // 清理
        }
    } while ( (n >>>= 1) != 0); // log(n) 限制--对数次
    return removed;
}

3. expungeStaleEntry(int staleSlot) 方法

作用:从staleSlot位置开始,清理key为null的Entry,直到entry为null的位置。过程中,遇到的entry不为空,并且entry.get()不为空的元素,进行rehash重新确定该元素位置。

private int expungeStaleEntry(int staleSlot) {
     
    Entry[] tab = table;
    int len = tab.length;

    // 清理staleSlot位置的Entry对象
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;

    // rehash直到entry为null
    Entry e;
    int i;
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null; // entry不为null
         i = nextIndex(i, len)) {
     
        ThreadLocal<?> k = e.get();
        if (k == null) {
      // 过期Entry,处理方式同staleSlot
            e.value = null;
            tab[i] = null;
            size--;
        } else {
     
            // rehash计算出当前Entry索引
            int h = k.threadLocalHashCode & (len - 1);
            if (h != i) {
      // 不相等,说明原位置是探测出的。
                tab[i] = null; // 原位置对象置空

                // 如果h索引位置不为null,向后探测,直到找到null位置
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i; // i位置 (entry = tab[i]) == null
}

你可能感兴趣的:(直面Java,并发与高并发专题,ThreadLocalMap,ThreadLocal)