ThreadLocal

发表于 | 更新于 | 分类于 ， | 评论数：

前言

顾名思义，ThreadLocal 用于保存每个线程的本地变量，每个线程都有一个 threadLocals 成员：

1
2
3
public class Thread implements Runnable {
    ThreadLocal.ThreadLocalMap threadLocals = null;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ThreadLocal<T> {
    static class ThreadLocalMap {
        static class Entry extends WeakReference<ThreadLocal<?>> {
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }

        // ...
    }

    private Entry[] table;
}

可以看到，ThreadLocalMap 存储了 ThreadLocal 与 Object 的键值对 Entry，而 Entry 中的 key 则是一种弱引用。一个对象，如果只有通过弱引用才能到达，则称为弱可达的。弱可达的对象，是可以被垃圾收集器进行回收的。

只得注意的是，虽然threadLocals属于每个thread对象，但是却是通过ThreadLocal来管理的。

##　导航

set

在调用 ThreadLocal.set(T value)时，将会将<threadLocal,value>键值对保存至当前线程的 threadLocals 中，从而成为当前线程的独有变量。

set 方法非常简单。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void set(T value) {
    Thread t = Thread.currentThread();
    // 获得当前线程对应的ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

注意到，threadLocals 并不会随着 Thread 的初始化而被初始化，而是在确实需要保存变量的时候才会被初始化。

get

get 方法也很简单，而get方法中也可能进行初始化：

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
32
33
34
public T get() {
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 获取t的ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        // 从map中获得对应的entry
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 保证map中含有初始化值
    return 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;
}

// 只有在确实有value需要保存的时候，才会初始化
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

ThreadLocalMap

Thread、ThreadLocal与ThreadLocalMap

通过以上 ThreadLocal 的 get/set 方法，我们知道虽然调用的是 ThreadLocal 里的方法，受影响的却是 Thread 中的 threadLocals。ThreadLocalMap 是真正连接 Thread 与 ThreadLocal 的类：thread拥有threadLocalMap，threadLocalMap以threadLocal为key值。

那为什么不直接在Thread中增加成员变量来存储独有变量呢？笔者认为，从获取变量的效率来看，散列表优于链表。而釆用散列表，就必须寻找一个合适的key绑定value。object.hashcode无疑是key键的优选。所以自然而然的，我们需要寻求一个对象来充当key。java中的这个对象，就是ThreadLocal了，而map，自然是ThreadLocalMap。

因此，ThreadLocal除了暴露对外接口，另一个重要作用是绑定value，提供高效查询。

ThreadLocalMap是一个定制的 map。在 ThreadLocalMap 中，key 虽然是 threadLocal，但是，get/set 时，用于判断的并不是直接继承于 Object 类的 hashcode，而是采用自 0 递增的 hashcode，保证了散列效果。

1
2
3
4
5
6
7
8
9
10
private final int threadLocalHashCode = nextHashCode();

private static AtomicInteger nextHashCode = new AtomicInteger();

// 在table是2的幂次情况下，使顺序计算的哈希效果近似于最优扩展的乘法哈希计算
private static final int HASH_INCREMENT = 0x61c88647;

private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

ThreadLocalMap.set

产生散列冲突的时候，ThreadLocalMap 采取线性探测法处理：

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
32
private void set(ThreadLocal<?> key, Object value) {

    Entry[] tab = table;
    int len = tab.length;
    // 根据threadLocalHashCode来计算对应的table下标
    int i = key.threadLocalHashCode & (len-1);

    // 线性探测
    // 这里并没有使用fast path，是因为创建一个新entry和替换原有entry至少概率相等，fast path失败的概率大于成功概率
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();
        // key存在，直接替换
        if (k == key) {
            e.value = value;
            return;
        }
        // k为null而entry不为null，说明key被回收
        if (k == null) {
            // 用新的key与value替换旧值
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    tab[i] = new Entry(key, value);
    int sz = ++size;
    // 清除旧entry
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

ThreadLocalMap.get

和 set 方法不同，get 只处理 fast path——由 key.hash 直接得到的 table[i]。如果通过 fast path 没有获得正确的 entry，则线性探测着清除对应下标的 entry 直至遇上 entry==null，之后返回 null。

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
private Entry getEntry(ThreadLocal<?> key) {
    // 根据threadLocalHashCode来计算对应的table下标
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    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;

    // 开始清除entry
    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 为了弱引用做了额外的处理。

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
// 从i开始往后扫描，介于不扫描（快速但会遗留垃圾）和完全扫描（线性时间）之间，对数时间
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); // 清除i后的旧entry，并返回之后的第一个非旧entry
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}

// 返回staleSlot后第一个null的下标，并清除之间的旧entry
private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;

    // 清除entry
    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);
            // 不等说明非fast path,重新放置
            if (h != i) {
                tab[i] = null;
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}

// 替换旧entry
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                                    int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    int slotToExpunge = staleSlot;
    // slotToExpunge=staleSlot之前的第一个等于null的index
    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();

        // key有冲突
        if (k == key) {
            e.value = value;
            // 将 tab[i]与tab[staleSlot]互换，以保持散列表的结构（避免中间掺杂null）
            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;

            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // 没有找到key对应的entry，新建一个
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);

    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}