线程本地变量ThreadLocal源码解读

一、ThreadLocal基础知识

　 ThreadLocal是线程的一个本地化对象，或者说是局部变量。当工作于多线程中的对象使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程分配一个独立的变量副本。所以每一个线程都可以独立地改变自己的副本，而不会影响其他线程所对应的副本。

　　ThreadLocal不是用来解决对象共享访问问题的，而主要是提供了线程保持对象的方法和避免参数传递的方便的对象访问方式

　　ThreadLocal的应用场合，最适合的是按线程多实例（每个线程对应一个实例）的对象的访问，并且这个对象很多地方都要用到。

概括起来说，对于多线程资源共享的问题，同步机制synchronized采用了“以时间换空间”的方式，比如定义一个static变量，同步访问，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响

二：如何存放线程本地变量？

在ThreadLocal类中有一个ThreadLocalMap, 用于存放每一个线程的变量副本,Map中元素的key为线程对象，value为对应线程的变量副本。

另外，说ThreadLocal使得各线程能够保持各自独立的一个对象，并不是通过ThreadLocal.set()来实现的，而是通过每个线程中的new 对象的操作来创建的对象，每个线程创建一个，不是什么对象的拷贝或副本。通过ThreadLocal.set()将这个新创建的对象的引用保存到各线程的自己的一个map中，每个线程都有这样一个map，执行ThreadLocal.get()时，各线程从自己的map中取出放进去的对象，因此取出来的是各自自己线程中的对象，ThreadLocal实例是作为map的key来使用的。

　　如果ThreadLocal.set()进去的东西本来就是多个线程共享的同一个对象，那么多个线程的ThreadLocal.get()取得的还是这个共享对象本身，还是有并发访问问题。

归纳了两点：
1。每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。
2。将一个共用的ThreadLocal静态实例作为key，将不同对象的引用保存到不同线程的ThreadLocalMap中，然后在线程执行的各处通过这个静态ThreadLocal实例的get()方法取得自己线程保存的那个对象，避免了将这个对象作为参数传递的麻烦。

当然如果要把本来线程共享的对象通过ThreadLocal.set()放到线程中也可以，可以实现避免参数传递的访问方式，但是要注意get()到的是那同一个共享对象，并发访问问题要靠其他手段来解决。但一般来说线程共享的对象通过设置为某类的静态变量就可以实现方便的访问了，似乎没必要放到线程中。

ThreadLocal的应用场合，我觉得最适合的是按线程多实例（每个线程对应一个实例）的对象的访问，并且这个对象很多地方都要用到。

三、源码解读

很多人对ThreadLocal存在一定的误解，说ThreadLocal中有一个全局的Map，set时执行map.put(Thread.currentThread(), value)，get和remove时也同理

首先看一下ThreadLocal的API：

get()：返回此线程局部变量的当前线程副本中的值。
protected T initialValue()：返回此线程局部变量的当前线程的“初始值”。
void remove()：移除此线程局部变量当前线程的值。
void set(T value)：将此线程局部变量的当前线程副本中的值设置为指定值。

　　 set方法：

/**

 * Sets the current thread's copy of this thread-local variable

 * to the specified value.  Most subclasses will have no need to

 * override this method, relying solely on the {@link #initialValue}

 * method to set the values of thread-locals.

 *

 * @param value the value to be stored in the current thread's copy of

 *        this thread-local.

 */

public void set(T value) {

    // 获取当前线程对象

    Thread t = Thread.currentThread();

    // 获取当前线程本地变量Map

    ThreadLocalMap map = getMap(t);

    // map不为空

    if (map != null)

        // 存值

        map.set(this, value);

    else

        // 创建一个当前线程本地变量Map

        createMap(t, value);

}  

/**

 * Get the map associated with a ThreadLocal. Overridden in

 * InheritableThreadLocal.

 *

 * @param  t the current thread

 * @return the map

 */

ThreadLocalMap getMap(Thread t) {

    // 获取当前线程的本地变量Map

    return t.threadLocals;

}

这里注意，ThreadLocal中是有一个Map，但这个Map不是我们平时使用的Map，而是ThreadLocalMap，ThreadLocalMap是ThreadLocal的一个内部类，不对外使用的。当使用ThreadLocal存值时，首先是获取到当前线程对象，然后获取到当前线程本地变量Map，最后将当前使用的ThreadLocal和传入的值放到Map中，也就是说ThreadLocalMap中存的值是[ThreadLocal对象, 存放的值]，这样做的好处是，每个线程都对应一个本地变量的Map，所以一个线程可以存在多个线程本地变量。

　　get方法：

/**

 * Returns the value in the current thread's copy of this

 * thread-local variable.  If the variable has no value for the

 * current thread, it is first initialized to the value returned

 * by an invocation of the {@link #initialValue} method.

 *

 * @return the current thread's value of this thread-local

 */

public T get() {

    Thread t = Thread.currentThread();

    ThreadLocalMap map = getMap(t);

    if (map != null) {

        ThreadLocalMap.Entry e = map.getEntry(this);

        if (e != null)

            return (T)e.value;

    }

    // 如果值为空，则返回初始值

    return setInitialValue();

}

看了之前set方法的分析，get方法也同理，需要说明的是，如果没有进行过set操作，那从ThreadLocalMap中拿到的值就是null。

四、使用场景

　　ThreadLocal对象通常用于防止对可变的单实例变量或全局变量进行共享。

　　当一个类中使用了static成员变量的时候，一定要多问问自己，这个static成员变量需要考虑线程安全吗？也就是说，多个线程需要独享自己的static成员变量吗？如果需要考虑，不妨使用ThreadLocal。

　　ThreadLocal的主要应用场景为多线程多实例（每个线程对应一个实例）的对象的访问，并且这个对象很多地方都要用到。例如：同一个网站登录用户，每个用户服务器会为其开一个线程，每个线程中创建一个ThreadLocal，里面存用户基本信息等，在很多页面跳转时，会显示用户信息或者得到用户的一些信息等频繁操作，这样多线程之间并没有联系而且当前线程也可以及时获取想要的数据。

五、注意事项

　　ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal没有外部强引用来引用它，那么系统 GC 的时候，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value，如果当前线程再迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永远无法回收，造成内存泄漏。

其实，ThreadLocalMap的设计中已经考虑到这种情况，也加上了一些防护措施：在ThreadLocal的get(),set(),remove()的时候都会清除线程ThreadLocalMap里所有key为null的value。

但是这些被动的预防措施并不能保证不会内存泄漏：

使用static的ThreadLocal，延长了ThreadLocal的生命周期，可能导致的内存泄漏（参考ThreadLocal 内存泄露的实例分析）。
分配使用了ThreadLocal又不再调用get(),set(),remove()方法，那么就会导致内存泄漏。

为什么使用弱引用

从表面上看内存泄漏的根源在于使用了弱引用。网上的文章大多着重分析ThreadLocal使用了弱引用会导致内存泄漏，但是另一个问题也同样值得思考：为什么使用弱引用而不是强引用？

我们先来看看官方文档的说法：

To help deal with very large and long-lived usages, the hash table entries use WeakReferences for keys.
为了应对非常大和长时间的用途，哈希表使用弱引用的 key。

下面我们分两种情况讨论：

key 使用强引用：引用的ThreadLocal的对象被回收了，但是ThreadLocalMap还持有ThreadLocal的强引用，如果没有手动删除，ThreadLocal不会被回收，导致Entry内存泄漏。
key 使用弱引用：引用的ThreadLocal的对象被回收了，由于ThreadLocalMap持有ThreadLocal的弱引用，即使没有手动删除，ThreadLocal也会被回收。value在下一次ThreadLocalMap调用set,get，remove的时候会被清除。

比较两种情况，我们可以发现：由于ThreadLocalMap的生命周期跟Thread一样长，如果都没有手动删除对应key，都会导致内存泄漏，但是使用弱引用可以多一层保障：弱引用ThreadLocal不会内存泄漏，对应的value在下一次ThreadLocalMap调用set,get,remove的时候会被清除。

因此，ThreadLocal内存泄漏的根源是：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key就会导致内存泄漏，而不是因为弱引用。

综合上面的分析，我们可以理解ThreadLocal内存泄漏的前因后果，那么怎么避免内存泄漏呢？　

　　① 使用结束以后进行remove操作，避免ThreadLocal对象越来越大。

　　② 高并发的场景：由于ThreadLocal内部使用HashMap的原理，key=currentThread，因为HashMap是非线程安全的，一定要注意hashmap.resize的时候，可能会导致某几个CPU 100%的问题，进而导致应用出现资源耗尽等不可预知的问题。

在使用线程池的情况下，没有及时清理ThreadLocal，不仅是内存泄漏的问题，更严重的是可能导致业务逻辑出现问题。所以，使用ThreadLocal就跟加锁完要解锁一样，用完就清理。

参考资料：

ThreadLocal