ThreadLocal

线程局部缓存：为线程缓存数据，将数据本地化（脱离共享）

原理：

  1. 每个线程有一个ThreadLocalMap属性，本质就是一个map

  2. map里面存储的<key, value>称为键值对，存储键值对时需要先求取哈希值

​ 由于哈希值会出现冲突，所以会造成“错位”元素的出现（元素“理想位置”和实际存储位置不一样）

​ “理想位置”是指该ThreadLocal对象初次计算出的哈希值

​ 如果从“理想位置”到实际存储位置是连续的，这里称该序列是“紧凑”的

  1. map里存储的key是一个弱引用，其包装了当前线程中构造的ThreadLocal对象

​ 这意味着，只要ThreadLocal对象丢掉了强引用，那么在下次GC后，map中的ThreadLocal对象也会被清除

​ 对于那些ThreadLocal对象为空的map元素，这里称其为【垃圾值】，稍后会被主动清理

  1. map里存储的value就是缓存到当前线程的值，这个value没有弱引用去包装，需要专门的释放策略(如果key为null进行回收)

  2. 一个线程对应多个ThreadLocal，一个ThreadLocal只对应一个值

概念

  • ThreadLocal

    作为线程副本当中的Key(弱引用), 调用线程当中的ThreadLocalMap获得实际的value

  • ThreadLocalMap

    每个Thread中threadLocals中存储副本Map

  • Entry

    继承自WeekReference. Map中存储的值. ThreadLocal当中Key.

重要参数

ThreadLocal

1
2
3
4
5
6
7
8
9
 
// 每次实例化生成HashCode值, 用于定位solt
private final int threadLocalHashCode = nextHashCode(); 
// 存储全局HashCode用于累加
private static AtomicInteger nextHashCode = new AtomicInteger();
// HASH魔术值. 与黄金比例，斐波那契数列存在某种关系.产生完美的槽位分配，hash冲突的次数很少
private static final int HASH_INCREMENT = 0x61c88647;

// 用于子类来设置初始化参数
protected T initialValue() { return null;}

ThreadLocalMap

1
2
3
4
5
6
7
8
 
// Map初始容量，必须为2的冪
private static final int INITIAL_CAPACITY = 16; 
// 存储Map中的键值对实体
private Entry[] table; 
// Map元素数量
private int size = 0;
// 扩容阙值，值为实体长度的2/3
private int threshold;  // threshold = (2/3)*len

重要操作

ThreadLocal

get

  1. 获取线程当存储的ThreadLocalMap
  2. 通过ThreadLocal读取ThreadLocalMap当前的Entry
  3. 返回Entry中的值(return)
  4. 如果线程不存在Map或者未设置Entry.则创建Map和创建Entry
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
 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();
}
// 设置初始化
private T setInitialValue() {
  	// 调用自定义初始化
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
      	// 存入ThreadLocalMap中
        map.set(this, value);
    else
      	// 线程中创建ThreadLocalMap
        createMap(t, value);
    return value;
}

set

1
2
3
4
5
6
7
8
 
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

nextIndex(槽位置, 最大长度)

哈希值发生冲突时，计算下一个哈希值。此处使用线性探测寻址，只是简单地将索引+1扩容机制

prevIndex(槽位置, 最大长度)

线性探测，但是逆方向进行，即向前遍历. 简单地将索引-1扩容机制

expungeStaleEntry(槽位置)

删除槽位. 如果删除的槽位之前发生过冲突, 将重新恢复到理想位置

cleanSomeSlots(槽位置, 结束位置)

清除范围内的垃圾值(key被回收)

getEntryAfterMiss(key, 槽位, 实体)

遍历查找实体对象(边遍历边删除垃圾数据)

getEntry(key)

1
2
3
4
5
6
7
8
9
10
 
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);
}

rehash()

删除所有垃圾值, 如果当前容量大于3/4阀值将进行扩容

1
2
3
4
5
6
7
 
private void rehash() {
  	// 遍历删除所有垃圾值
    expungeStaleEntries();
		// 大小达到阈值的3/4进行扩容
    if (size >= threshold - threshold / 4)
        resize();
}

resize()

进行2倍扩容(重新进行hash插入新槽中)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2; // 扩容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; // Help the GC
            } else {
              	// 进行重新hash插入槽中
                int h = k.threadLocalHashCode & (newLen - 1);
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                count++;
            }
        }
    }
    setThreshold(newLen);
    size = count;
    table = newTab;
}

set(key, val)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
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();
				
        // 找到key进行替换val值
        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)
      	// 扩容进行重新hash
        rehash();
}