ThreadLocal源码分析与使用场景

一、概述

ThreadLocal，即线程变量，是一个以ThreadLocal对象为键、任意对象为值的存储结构。这个结构被附带在线程上，也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。可以通过set(T)方法来设置一个值，在当前线程下再通过get()方法获取到原先设置的值。
ThreadLocal实现的思路：Thread类中持有一个ThreadLocalMap的引用，用于存储每一个线程的变量副本，这个map在使用ThreadLocal变量时候被延迟创建和初始化，并在线程退出时候被释放。Map中元素的键为this所指向的ThreadLocal实例（并不是所以为的线程对象），而值对应需要使用的变量的副本。下面上源码

二、源码分析

1. 关于ThreadLocalMap属于Thread还是ThreadLocal之争

public
class Thread implements Runnable {

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

   }

以上可以看到Thread类中持有的ThreadLocalMap （）;同时，注释中指出了这个变量由ThreadLocal类来维护，下面就是今天的主角ThreadLocal；所以，这个map是被线程所持有的，但是其初始化和维护都是在ThreadLocal中。

2. ThreadLocal中的四个方法

2.1 get方法 及其调用的方法

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();
}
/**
 * Get the map associated with a ThreadLocal. Overridden in
 * InheritableThreadLocal.
 *
 * @param  t the current thread
 * @return the map
 */
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

/**
 * Variant of set() to establish initialValue. Used instead
 * of set() in case user has overridden the set() method.
 *
 * @return the initial value
 */
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;
}

/**
 * Create the map associated with a ThreadLocal. Overridden in
 * InheritableThreadLocal.
 *
 * @param t the current thread
 * @param firstValue value for the initial entry of the map
 * @param map the map to store.
 */
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

可以看到，threadLocals最初是从线程t获取。若尚未初始化，则调用 setInitialValue()

2.2 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();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

这里就可以看到，map的key并非原以为的当前线程对象，而是this，这时候this的指向应该是当前的ThreadLocal对象

2.3 remove方法

/**
 * Removes the current thread's value for this thread-local
 * variable.  If this thread-local variable is subsequently
 * {@linkplain #get read} by the current thread, its value will be
 * reinitialized by invoking its {@link #initialValue} method,
 * unless its value is {@linkplain #set set} by the current thread
 * in the interim.  This may result in multiple invocations of the
 * <tt>initialValue</tt> method in the current thread.
 *
 * @since 1.5
 */
 public void remove() {
     ThreadLocalMap m = getMap(Thread.currentThread());
     if (m != null)
         m.remove(this);
 }

无F可说

2.3 ThreadLocalMap–一个静态内部类

/**
 * ThreadLocalMap is a customized hash map suitable only for
 * maintaining thread local values. No operations are exported
 * outside of the ThreadLocal class. The class is package private to
 * allow declaration of fields in class Thread.  To help deal with
 * very large and long-lived usages, the hash table entries use
 * WeakReferences for keys. However, since reference queues are not
 * used, stale entries are guaranteed to be removed only when
 * the table starts running out of space.
 */
static class ThreadLocalMap {

    /**
     * The entries in this hash map extend WeakReference, using
     * its main ref field as the key (which is always a
     * ThreadLocal object).  Note that null keys (i.e. entry.get()
     * == null) mean that the key is no longer referenced, so the
     * entry can be expunged from table.  Such entries are referred to
     * as "stale entries" in the code that follows.
     */
    static class Entry extends WeakReference<ThreadLocal> {
        /** The value associated with this ThreadLocal. */
        Object value;

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

    /**
     * The initial capacity -- MUST be a power of two.
     */
    private static final int INITIAL_CAPACITY = 16;

    /**
     * The table, resized as necessary.
     * table.length MUST always be a power of two.
     */
    private Entry[] table;
.
.
.

可以看到，ThreadLocalMap是ThreadLocal的一个静态内部类，其中又有一个继承了WeakReference的Entity，是一个定制化的hashMap.

三、show the code

public class LeThreadLocal extends Thread {

    private static ThreadLocalValue threadLocalValue;
    ThreadLocal<ThreadLocalValue> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {

        for (int i = 0; i < 5; i++) {
            LeThreadLocal t = new LeThreadLocal();
            t.start();
        }

    }

    @Override
    public void run() {
        for (int j = 0; j < 5; j++) {
            getThreadLocalValue().setIndex(getThreadLocalValue().getIndex() + 1);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            getThreadLocalValue().setS(Thread.currentThread().getName());
            System.out.println(getThreadLocalValue());
        }
    }

    public ThreadLocalValue getThreadLocalValue() {
        if (threadLocal.get() == null) {
            threadLocal.set(new ThreadLocalValue(null, 0));
            getThreadLocalValue();
        }
        return threadLocal.get();

    }
}

class ThreadLocalValue {

    private String s;
    private int index;

    public String getS() {
        return s;
    }

    public void setS(String s) {
        this.s = s;
    }

    public int getIndex() {

        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    public ThreadLocalValue(String s, int index) {
        this.s = s;
        this.index = index;
    }

    @Override
    public String toString() {
        return "ThreadLocalValue{" +
                "s='" + s + '\'' +
                ", index=" + index +
                '}';
    }
}

测试输出

ThreadLocalValue{s='Thread-4', index=1}
ThreadLocalValue{s='Thread-0', index=1}
ThreadLocalValue{s='Thread-1', index=1}
ThreadLocalValue{s='Thread-2', index=1}
ThreadLocalValue{s='Thread-3', index=1}
ThreadLocalValue{s='Thread-4', index=2}
ThreadLocalValue{s='Thread-0', index=2}
ThreadLocalValue{s='Thread-3', index=2}
ThreadLocalValue{s='Thread-2', index=2}
ThreadLocalValue{s='Thread-1', index=2}
ThreadLocalValue{s='Thread-1', index=3}
ThreadLocalValue{s='Thread-4', index=3}
ThreadLocalValue{s='Thread-0', index=3}
ThreadLocalValue{s='Thread-3', index=3}
ThreadLocalValue{s='Thread-2', index=3}
ThreadLocalValue{s='Thread-1', index=4}
ThreadLocalValue{s='Thread-3', index=4}
ThreadLocalValue{s='Thread-4', index=4}
ThreadLocalValue{s='Thread-0', index=4}
ThreadLocalValue{s='Thread-2', index=4}
ThreadLocalValue{s='Thread-1', index=5}

ThreadLocalValue{s='Thread-0', index=5}
ThreadLocalValue{s='Thread-3', index=5}
ThreadLocalValue{s='Thread-4', index=5}
ThreadLocalValue{s='Thread-2', index=5}

分析： ThreadLocal变量的使用不同于普通变量，对于本例中的静态成员变量而言，应该在每次使用该变量的时候都首先在ThreadLocal中获取这个变量，而不是直接使用其引用进行操作。这也充分印证了，ThreadLocal为每个线程维护了一个副本，而不是多线程操作这个共享的变量。也就是说使用ThreadLocal类去维护一个变量，并不是为了让多线程共同去的效果叠加的操作这个变量，而是互不干涉的使用这个变量的副本，他们的效果不能叠加。

例子中的使用方式是，在可执行（Runnable）的类中维护一个ThreadLocal实例，并在初次使用需要隔离的变量时候，调用threadLocal.set(value)方法，并在后续操作和使用隔离变量value的时候都先在threadLocal中get，而不是直接操作变量的引用。
在Session维护的场景中也经常用到ThreadLocal，其使用方式是将比较宝贵的连接或者会话资源保存在threadLocal中，在这个线程的声明周期内都使用这个session；

易错点：
即便是ThreadLocal中变量，在使用时要先在threadLocal中get,而不是直接操作器引用，尤其是在类静态变量的使用上；要时刻想着去拿副本
在ThreadLocalMap中，key是当前threadLocal的实例，所以一个ThreadLocal只是维护了一个变量，如果有两个变量，那么需要用两个ThreadLocal的实例。

四、关于内存泄漏

（参考来源： http://blog.csdn.net/wudiyong22/article/details/52141608）

ThreadLocal的实现是这样的：每个Thread 维护一个 ThreadLocalMap 映射表，这个映射表的 key 是 ThreadLocal 实例本身，value 是真正需要存储的Object。也就是说 ThreadLocal 本身并不存储值，它只是作为一个 key 来让线程从 ThreadLocalMap 获取 value。值得注意的是图中的虚线，表示ThreadLocalMap 是使用 ThreadLocal 的弱引用作为 Key 的，弱引用的对象在 GC 时会被回收。

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。

防止措施：
在每次使用完ThreadLocal，都调用它的remove()方法，清除数据