ThreadLocal源码分析

ThreadLocal是什么？

ThreadLoal 变量，线程局部变量，同一个 ThreadLocal 所包含的对象，在不同的 Thread 中有不同的副本。这里有几点需要注意：

因为每个 Thread 内有自己的实例副本，且该副本只能由当前 Thread 使用。这是也是 ThreadLocal 命名的由来。
既然每个 Thread 有自己的实例副本，且其它 Thread不可访问，那就不存在多线程间共享的问题。

ThreadLocal实现原理

set方法的实现

在使用ThreadLocal的时候，用的最多的就是get和set两个方法。我们就先从set入手来分析ThreadLocal的实现原理。

public void set(T value) {
//获取当前线程
    Thread t = Thread.currentThread();
    //尝试获取当前线程的threadLocals
    ThreadLocalMap map = getMap(t);
    //如果当前线程的threadLocals不为空，就直接设值
    if (map != null)
        map.set(this, value);
    else
    //否则为当前线程设置threadLocals
        createMap(t, value);
}

这个方法中我们首先需要注意的一点就是 getMap(t)方法。
它的实现就一行代码return t.threadLocals;就是获取当前Thread对象的一个threadLocal属性。

在Thread类中有这么一个属性：

1	ThreadLocal.ThreadLocalMap threadLocals = null;

这里的 ThreadLocal.ThreadLocalMap就是ThreadLocal中的一个静态内部类。
从这里我们也可以看出，ThreadLocal每个线程的变量副本并不是存在ThreadLocal中的，而是存在线程对象（Thread）中的。

尝试直接从当前Thread对象中直接获取失败之后，就会执行createMap(t, value);方法，这个方法的具体实现如下：

void createMap(Thread t, T firstValue) {
//创建一个ThreadLocalMap对象，交由Thread对象的threadLocals属性保存
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

这里再一次印证了我们的结论。

现在我们基本清楚了ThreadLocal是如何为每个Thread维护变量副本的了，ThreadLocal实际上只充当了中间人的角色，实际上变量副本的存储是由每个线程本身完成的。

get方法的实现

下面我们来分析一下get方法的实现。

public T get() {
    //拿到当前线程
    Thread t = Thread.currentThread();
    //尝试获取线程对象中的threadLocal属性
    ThreadLocalMap map = getMap(t);
    if (map != null) {
    //尝试从该线程对象的threadLocal属性中取值
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
        //却遇到值了，就完成类型转换，并返回
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    //没有取到，就返回初始值。
    return setInitialValue();
}

通过代码不难看出，get方法就是简简单单的从Thread对象中取值，如果取到了就返回，没取到就返回初始值。

ThreadLocalMap源码分析

通过对set、get方法的源码分析，我们可以清楚的知道，每个线程的变量副本实际上是由线程对象本身通过一个ThreadLocalMap对象存储的。而ThreadLocalMap是ThreadLocal中的一个静态内部类。想要搞清楚整个原理，这个ThreadLocalMap的实现就是绕不开的。那么下面，我们来看一下它的内部实现。

TreadLocalMap本质上也是一个Map，那么我们首先看一下它的节点类。

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

如果熟悉HashMap源码的同学可能就已经看出不同来了，这个Entry继承自WeakReference。这里的WeakReference<ThreadLocal<?>>,ThreadLocal就是弱引用对象，如果ThreadLocal对象没有被任何强引用指向时，一旦发生GC无论内存空间是否足够，都会被回收。

既然是Map，那么我们就从set和get方法来入手来分析一下这个Map和我们熟悉的HashMap等有什么区别。

下面我们就来看一个set方法的具体实现；

 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();
//如果table[i]上的key不为空，并且和当前key相同，更新value
                if (k == key) {
                    
                    e.value = value;
                    return;
                }

                if (k == null) {
                    /*如果table[i]上的key为空，说明已经弱引用对象
                    ThreadLocal被回收了，这个地方就可以重新使用了
                    重新设置key（ThreadLocal），替换掉value
                    */
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

     //找到为空的位置。插入节点
            tab[i] = new Entry(key, value);
     		//更新容量       
     		int sz = ++size;
     /*
     cleanSomeSlots(i, sz)用于回收那些key已经被回收了的节点
     */
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                //如果负载因子达到了所定义地址，那么进行rehash
                rehash();
        }

rehash是每个Map必须要分析的方法，那么我们看一下ThreadLocalMap是如何rehash的。

private void rehash() {
    //清理所有无效的entry，即key被回收了的entry
           expungeStaleEntries();

		//如果清理后，还size依然大于掉地了的阈值，则进行扩容
           if (size >= threshold - threshold / 4)
               resize();
       }

下面我们重点看一下，resieze方法

private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;
    //新申请一个长度为原来两倍的entry数组
    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;
}

这段代码的逻辑还是比较清晰的。新建一个长度为原先两倍的Entry数组，然后把旧数组中的数据重新计算索引后放入新的Entry数组。

看完了ThreadLocalMap是如何存的，下面我们就来分析一下，ThreadLocalmap是如何取得。


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
        //通过key计算出得直接索引找到不value得时候
        //调用这个方法
        return getEntryAfterMiss(key, i, e);
}

取到了直接返回，没取了就调用了getEntryAfterMiss方法。

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)
                   //清楚无效得entry
                   expungeStaleEntry(i);
               else
                   //基于线性探测法向后扫描
                   i = nextIndex(i, len);
               e = tab[i];
           }
           return null;
       }

到此，我们清楚了ThreadLocalMap是如何工作的了。

ThreadLocal可能引起的内存泄露

刚才我们分析了ThreadLocalMap，我们知道这个Map的key是一个弱引用对象，当没有强引用指向这个作为key的弱引用对象之后，它会被下一次gc回收掉，失去了key，我们就无法再访问Map中的value了，但是value却不会被回收，因为存在一条current thread连接过来的强引用，只有当前thread结束以后，强引用才会断开，这个时候Current Thread，Map，value才会被GC回收。

示意图

在之前的源码分析的时候，我们也看到了在get，set等方法中都清除了ThreadLocalMap中所有key为null的value。一定程度上缓解了内存泄漏的风险，但是这些被动的预防措施不能确保不发生内存泄漏。

而且很多时候使用static修饰ThreadLocal延长ThreadLocal的生命周期，可能导致内存泄漏。但是我们也不能说用static修饰ThreadLocal就不好，其实用static修饰还是有好处的，它可以避免重复创建等同的对象。

我们在使用的时候，一定要注意调用remove方法。