ThreadLocal

ThreadLocal用来提供线程内部的局部变量，这种变量在多线程环境下访问时能保证各个线程的变量相对独立于其他线程内的变量。不同线程之间不会相互干扰，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或者组件之间一些公共变量传递的复杂度。

ThreadLocal实例通常来说都是private static类型的，用于关联线程和线程上下文。

一、ThreadLocal与synchronized的区别

	synchronized	ThreadLocal
原理	同步机制采用以时间换空间的方式，只提供一份变量，让不同的线程排队访问	以空间换时间的方式，为每一个线程提供一份变量的副本，从而实现同时访问而相互不干扰
侧重点	多个线程之间访问资源的同步	多个线程中让每个线程之间的数据相互隔离

二、ThreadLocal内部数据结构

jdk8的设计方案两个好处

1、每个map存储的Entry数量变少。

2、当Thread销毁的时候，ThreadLocalMap也会随之销毁，减少内存的使用。

三、ThreadLocal核心源码

方法声明	说明
protected T initialValue()	返回当前线程局部变量的初始值
public void set(T value)	设置当前线程绑定的局部变量
public T get()	获取当前线程绑定的局部变量
public void remove()	移除当前线程绑定的局部变量

 1、set

public void set(T value) {
    //获取当前线程对象
    Thread t = Thread.currentThread();
    //获取当前线程中维护的ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null)
        //如果map存在，则将当前的ThreadLocal设置进入map中
        map.set(this, value);
    else
        //如果不存在map，则创建一个ThreadLocalMap关联到当前线程上
        createMap(t, value);
}

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

void createMap(Thread t, T firstValue) {
    //this为当前的ThreadLocal对象
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

2、get

public T get() {
    //获取当前线程对象
    Thread t = Thread.currentThread();
    //获取当前线程中维护的ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        //从ThreadLocalMap中取出ThreadLocal对象
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    //1、map不存在，表示此线程没有维护ThreadLocalMap对象
    //2、map存在，但是没有与当前ThreadLocal关联的entry对象
    return setInitialValue();
}

private T setInitialValue() {
    //子类重写的方法，默认值返回null
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

先获取当前线程的ThreadLocalMap变量，如果存在则返回entry里的值，如果不存在则创建并返回初始值。

3、remove

public void remove() {
    //获取当前线程关联的ThreadLocalMap
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        //如果存在，则将ThreadLocal对象从map中移除
        m.remove(this);
}

四、ThreadLocalMap源码

ThreadLocalMap是ThreadLocal的内部类，没有实现Map接口，单独实现了Map的功能。

//省略了属性和方法
static class ThreadLocalMap {
   
    static class Entry extends WeakReference<ThreadLocal<?>> {
        /** The value associated with this ThreadLocal. */
        Object value;

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

1、属性

//map的容量，且必须是2的次幂
private static final int INITIAL_CAPACITY = 16;

//Entry数组，长度为是2次幂
private Entry[] table;

//存放Entry的个数
private int size = 0;

//table扩容的阈值
private int threshold; // Default to 0

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    table = new Entry[INITIAL_CAPACITY];
    //这行代码其实在jdk7hashmap源码里也有类似的，就是因为计算索引使用了位运算“&”
    //所以容量要为2的次幂
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    setThreshold(INITIAL_CAPACITY);
}

2、Entry

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

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

 

 

从上面的分析可以知道，无论ThreadLocalMap中的key使用哪一种类型引用都无法完全避免内存泄漏。

（1）避免内存泄漏的两种方式

        a）使用完ThreadLocal，调用其remove方法删除对应的Entry

        b）使用完ThreadLocal，当前Thread也随之运行结束

（2）使用弱引用的原理

相对第一种方式，第二种方式显然不好控制，特别是使用线程池的时候，线程结束是不会销毁的。

只要在使用完ThreadLocal后及时调用remove，无论key是强引用还是弱引用，都不会有问题。而jdk使用弱引用是因为ThreadLocalMap中的setEntry，getEntry和remove方法中，会对key为null时（即ThreadLocal为null）进行处理，设置对应的value为null。

因此，在使用完ThreadLocal，当前线程依然运行的前提下，就算忘记调用remove方法，弱引用比强引用多一层保障，弱引用的ThreadLocal被回收，对应的value在下一次ThreadLocalMap调用setEntry，getEntry和remove中的任意一个方法时候都会被清除，从而大大降低内存泄漏的风险。

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

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)
            //处理key为null的情况
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}z

注意，在setEntry时，会使用启发式扫描，除了清楚当前null key之外，清楚临近的null key。