瞅瞅源码之ThreadLocal

ThreadLocal ThreadLocalMap Thread 三者之间的关系

 

ThreadLocalMap是ThreadLocal的一个内部类

/**
 * ThreadLocalMap是一个定制的散列映射，只适合维护线程本地值。
 * 在ThreadLocal类之外不导出任何操作。
 * The class is package private to allow declaration of fields in class Thread.
 * 类是包私有的，允许在类线程中声明字段。-> Thread.java 中含有 ThreadLocalMap属性
 * 为了帮助处理非常大且长期存在的使用，哈希表条目使用WeakReferences作为键。
 * 但是，由于不使用引用队列，所以只有当表开始耗尽空间时，才保证删除陈旧的条目。
 */
static class ThreadLocalMap { //sth ...}

 

Thread中含有这个内部类的属性

/* ThreadLocal values pertaining to this thread. This map is maintained
 * by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;

/*
 * InheritableThreadLocal values pertaining to this thread. This map is
 * maintained by the InheritableThreadLocal class.
 */
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

 

这个内部类的属性是在哪里赋值的？

我们创建完一个ThreadLocal会使用set方法赋值，看下这个set是怎么实现的

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        //note :  Thread中ThreadLocal属性的初始化是这个这个方法被被第一次调用的时候进行的 -> createMap
        createMap(t, value);
}

void createMap(Thread t, T firstValue) {
    //这里初始化Thread的threadLocal属性的值
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

 

看明白上边三者之间的关系之后，看下ThreadLocal中的几个方法

• ThreadLocal()
• <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier)
• void set(T value)
• T get()
• void remove()
• T initialValue()

 

第一个是个构造函数就不需要多说什么了

第二个方法先看下源码 （注意这是个静态方法）

/**
 * 创建线程本地变量。变量的初始值是通过调用{@code Supplier}上的{@code get}方法确定的。
 *
 * @param <S>      the type of the thread local's value
 * @param supplier 用于确定初始值的供应商
 * @return 一个新的线程局部变量
 * @throws NullPointerException if the specified supplier is null
 * @since 1.8
 */
public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
    return new SuppliedThreadLocal<>(supplier);
}

通过源码以及上边的UML类图我们可以知道，这个方法创建了一个ThreadLocal的内部类 SuppliedThreadLocal ，这个方法是1.8有了Supplier类之后新增的，

Supplier也就是这个ThreadLocal的value的源头

/**
 * ThreadLocal的一个扩展，它从指定的{@code Supplier}获取初始值。
 */
static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {

    private final Supplier<? extends T> supplier;

    SuppliedThreadLocal(Supplier<? extends T> supplier) {
        this.supplier = Objects.requireNonNull(supplier);
    }
    //注意这里实现了ThreadLocal的protected方法 -> initialValue
    @Override
    protected T initialValue()
        return supplier.get();
    }
}

 

第三个方法 set() ： 将当前线程的线程本地变量副本设置为指定的值。

public void set(T value) {
    //获取当前线程
    Thread t = Thread.currentThread();
    //获取当前线程中的threadLocals属性的对象 -> t.threadLocals
    ThreadLocalMap map = getMap(t);
    if (map != null)
        //如果不为空，说明这个属性初始化过，直接赋值
        map.set(this, value);
    else
        //note :  Thread中ThreadLocal属性的初始化是这个这个方法被被第一次调用的时候进行的
        //t.threadLocals = new ThreadLocalMap(this, firstValue);
        createMap(t, value);
}

 

第四个方法 get() ：返回此线程本地变量的当前线程副本中的值。如果变量没有当前线程的值，则首先将其初始化为调用initialValue方法返回的值。

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;
        }
    }
    //map为null也就是Thread中的threadLocals属性没有初始化
    return setInitialValue();
}

private T setInitialValue() {
    //注意initialValue这个方法，默认返回的是null。
    T value = initialValue();
    //这里的逻辑其实就是和set方法中的一致了，注意这里的校验逻辑不是没有必要的
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        //如果重复调用get()，其实这里最少会执行N-1次。
        map.set(this, value);
    else
        //createMap()方法只有两处调用，一个get  一个set  
        //在get中被调用的情况是 ThreadLocal对象创建之后没有调用set()直接调用get()
        createMap(t, value);
    //如果子类没有自己实现initialValue(),那么这里返回的其实就是null
    return value;
}

 

第五个方法 remove（）

/**
 * 移除此线程本地变量的当前线程值。
 * 如果这个线程本地变量remove()后重新调用get()方法，那么它的值将通过调用它的initialValue()方法重新初始化，
 * --除非它的值是当前线程在此调用get()之前调用了set()。
 * 这可能导致在当前线程中多次调用{@code initialValue}方法。
 *
 * @since 1.5  这个方法是1.5新增的。但是需要注意的是线程结束之后，这个线程的局部变量也就是 Thread.threadLocals等都会
 * 自动被垃圾回收，所以显式的调用此方法并不是必须的，只是这么做会加快内存回收的速度。
 */
public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

 

第六个方法： initialValue（）

/**
 * 返回当前线程的初始值。
 * 这个方法将在线程第一次使用{@link #get}方法访问变量时被调用，除非线程之前调用了{@link #set}方法，
在这种情况下不会为线程调用{@code initialValue}方法。
 * 通常，每个线程最多调用该方法一次，但是在随后调用{@link #remove}和{@link #get}时，可能会再次调用该方法。
 * <p>
 * 这个实现只返回{@code null};
 * 如果程序员希望线程局部变量的初始值不是{@code null}，则必须子类化{@code ThreadLocal}，并重写此方法。
 * 通常，将使用匿名内部类。 比如说 SuppliedThreadLocal
 *
 * @return the initial value for this thread-local
 */
protected T initialValue() {
    return null;
}

 

 

还有一个问题，为什么ThreadLocalMap使用弱引用呢？既然都知道是弱引用了还猜意图干嘛，当然是为了更好的内存回收啊！

 

最后一个问题ThreadLocal为什么会引起内存泄露？

因为：ThreadLocalMap使用ThreadLocal的弱引用作为key.

 

贴一张网图

如上图，ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal没有外部强引用引用他，那么系统gc的时候，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value，如果当前线程再迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链：

ThreadLocal Ref -> Thread -> ThreaLocalMap -> Entry -> value

永远无法回收，造成内存泄露。

 

怎么办？

手动调用ThreadLocal的remove函数，删除不使用的ThreadLocal。

将ThreadLocal设置为 private static （看下本文开始的译文），这样的话ThreadLocal的生命周期就更长，由于一直存在ThreadLocal的强引用，所以ThreadLocal也就不会被回收，也就能保证任何时候都能根据ThreadLocal的弱引用访问到Entry的value值，然后remove它，防止内存泄露。