ThreadLocal解析

cblstc

已于 2024-07-16 11:35:00 修改

阅读量82

点赞数

分类专栏： Java

于 2021-07-30 18:55:46 首次发布

本文链接：https://blog.csdn.net/cblstc/article/details/119254361

版权

java 前端算法

Java 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

文章目录

set

设置跟当前线程关联的值。首先拿到当前线程，然后获取当前线程绑定的ThreadLocalMap，如果能拿到，就设置值；否则创建map。

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

getMap

可以看到getMap获取的是当前线程的一个变量ThreadLocalMap，而这个变量是ThreadLocal的内部类。

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}
class Thread {
	ThreadLocal.ThreadLocalMap threadLocals = null;
}

createMap

createMap很简单，就直接new一个ThreadLocalMap，传ThreadLocal和初始值

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

ThreadLocalMap

来看下ThreadLocalMap，定义了一个Entry内部类，用来存放Thread和value，注意是WeakReference类型。

构造方法初始化了一个大小为16的Entry数组，然后hash计算ThreadLocal需要存放的位置，setThreshold设置负载因子为当前长度的2/3

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
        super(k); // 这里走的是WeakReference的构造方法，即把key设置成WeakReference
        value = v;
    }
}

// Entry数组，大小为2的n次
private Entry[] table;

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    table = new Entry[INITIAL_CAPACITY];
  	// 对hashcode取模
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    setThreshold(INITIAL_CAPACITY);
}

private void setThreshold(int len) {
  threshold = len * 2 / 3;
}

get

get方法还是取当前线程，然后拿到绑定的ThreadLocalMap，再根据当前ThreadLocal从Entry[]中取value。如果不存在ThreadLocalMap，则初始化一个。

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

getEntry

我们看下getEntry如何拿到值，也是比较简单，拿到ThreadLocal的hashcode，取模找到下标，找到Entry，判断Entry的key是否等于当前ThreadLocal，如果是，就是我们想要的值了。如果否，说明找错了，那么调用getEntryAfterMiss继续找。

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

getEntryAfterMiss

这个方法是在getEntry找不到想要的值的时候会调用。可以看到入参需要传递Entry，这个Entry在上面由getEntry查出来。

while循环出口是e != null，主要看else分支，取下一个index（直到数组最后一个），然后判断是否是我们想要的值（key等于当前ThreadLocal）

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 //取下一个index
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0);
}

setInitialValue

初始化逻辑和set方法类似，只不过初始值是从initialValue方法获取，默认是null

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

protected T initialValue() {
  return null;
}

remove

我们经常被告知，使用完ThreadLocal记得要remove防止内存泄露。

remove操作是一个简单的table删除操作，即根据ThreadLocal找到相应的Entry删除。

public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

private void remove(ThreadLocal<?> key) {
  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)]) {
    if (e.get() == key) {
      e.clear();
      expungeStaleEntry(i);
      return;
    }
  }
}