ThreadLocal的使用及原理

2020-09-21 约 2574 字预计阅读 6 分钟次阅读 java

作用

threadlocal最大作用就是提供线程级别的变量生命周期。

试想，如果你需要一个变量在一个线程的生命周期内都可以访问到，在不使用threadlocal的前提下你会怎么做？你或许这样做

提供一个类级别或者静态变量但是这个方法大家很容易就想到在高并发时会出问题。
把这个局部变量一直传递下去但是如果你要调用的方法层次很深呢？难道你对每个方法都增加一个参数吗？显然不实际。

所以threadlocal就是提供了一个可行的方案，使得这个变量可以随时访问到，并且不会跟其他线程产生冲突。

使用

threadlocal的使用很简单，就是一个get, set。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


public class ThreadLocalTest {
    //定义一个ThreadLocal的变量, 需要指定类型
    public static ThreadLocal<String> threadLocal = new InheritableThreadLocal<>();

    @Before
    public void init() {
        threadLocal.set("test");
    }

    @Test
    public void test() {
        //在需要时get出来
        System.out.println("threadLocal's value=" + threadLocal.get());
    }
}

实现原理

ThreadLocal.set() 实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


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 getMap(Thread t) {
    return t.threadLocals;
}

从上面代码中看出来：

从当前线程Thread中获取ThreadLocalMap实例。

ThreadLocal实例和value封装成Entry。

接下去看看Entry存入table数组如何实现的：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


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

1.通过ThreadLocal的nextHashCode方法生成hash值。

1
2
3
4


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

从nextHashCode方法可以看出，ThreadLocal每实例化一次，其hash值就原子增加HASH_INCREMENT。

2.通过 hash & (len -1) 定位到table的位置i，假设table中i位置的元素为f。

3.如果f != null，假设f中的引用为k：

如果k和当前ThreadLocal实例一致，则修改value值，返回。
如果k为null，说明这个f已经是stale(陈旧的)的元素。调用replaceStaleEntry方法删除table中所有陈旧的元素（即entry的引用为null）并插入新元素，返回。
否则通过nextIndex方法找到下一个元素f，继续进行步骤3。如果f == null，则把Entry加入到table的i位置中。通过cleanSomeSlots删除陈旧的元素，如果table中没有元素删除，需判断当前情况下是否要进行扩容。

4.如果f == null，则把Entry加入到table的i位置中。

5.通过cleanSomeSlots删除陈旧的元素，如果table中没有元素删除，需判断当前情况下是否要进行扩容。

table扩容

如果table中的元素数量达到阈值threshold的3/4，会进行扩容操作，过程很简单：

 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


private void resize() {
    //旧数组
    Entry[] oldTab = table;
    
    //旧数组长度
    int oldLen = oldTab.length;
    //新数组长度 = 旧数组长度*2
    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; // Help the GC
            } 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;
}

1.新建新的数组newTab，大小为原来的2倍。

2.复制table的元素到newTab，忽略陈旧的元素，假设table中的元素e需要复制到newTab的i位置，如果i位置存在元素，则找下一个空位置进行插入。

ThreadLocal.get() 实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


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

获取当前的线程的threadLocals。

如果threadLocals不为null，则通过ThreadLocalMap.getEntry方法找到对应的entry，如果其引用和当前key一致，则直接返回，否则在table剩下的元素中继续匹配。

如果threadLocals为null，则通过setInitialValue方法初始化，并返回。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


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

魔数0x61c88647

生成hash code间隙为这个魔数，可以让生成出来的值或者说ThreadLocal的ID较为均匀地分布在2的幂大小的数组中。

1
2
3
4
5


private static final int HASH_INCREMENT = 0x61c88647;

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

可以看出，它是在上一个被构造出的ThreadLocal的ID/threadLocalHashCode的基础上加上一个魔数0x61c88647的。
这个魔数的选取与斐波那契散列有关，0x61c88647对应的十进制为1640531527。
斐波那契散列的乘数可以用(long) ((1L « 31) * (Math.sqrt(5) - 1))可以得到2654435769，如果把这个值给转为带符号的int，则会得到-1640531527。换句话说(1L « 32) - (long) ((1L « 31) * (Math.sqrt(5) - 1))得到的结果就是1640531527也就是0x61c88647。
通过理论与实践，当我们用0x61c88647作为魔数累加为每个ThreadLocal分配各自的ID也就是threadLocalHashCode再与2的幂取模，得到的结果分布很均匀。
ThreadLocalMap使用的是线性探测法，均匀分布的好处在于很快就能探测到下一个临近的可用slot，从而保证效率。。为了优化效率。

ThreadLocal与内存泄漏

之所以有关于内存泄露的讨论是因为在有线程复用如线程池的场景中，一个线程的寿命很长，大对象长期不被回收影响系统运行效率与安全。如果线程不会复用，用完即销毁了也不会有ThreadLocal引发内存泄露的问题
当我们仔细读过ThreadLocalMap的源码，我们可以推断，如果在使用的ThreadLocal的过程中，显式地进行remove是个很好的编码习惯，这样是不会引起内存泄漏。
如果您必须使用ThreadLocal，请确保在您完成该操作后立即删除该值，并且最好在将线程返回到线程池之前。最佳做法是使用remove() 而不是set(null)，因为这将导致WeakReference立即被删除，并与值一起被删除。

目录