ThreadLocal浅析

1.目的

ThreadLocal目的是保存一些线程级别的全局变量，比如connection，或者事务上下文，避免这些值需要一直通过函数参数的方式一路传递。

2. 常见用法

public class Test2 {public static void main(String[] args) throws InterruptedException {testThreadLocal();}private static void testThreadLocal() {Util.setGlobalName("zili.dengzl");new Foo().printName();}}class Foo{public void printName(){System.out.println("globalName="+Util.getGlobalName());}}class Util {private static final ThreadLocal<String> globalName = new ThreadLocal<String>();public static String getGlobalName() {return globalName.get();}public static void setGlobalName(String name) {globalName.set(name);}}

3.实现分析

要实现上面这样的功能，最简单的想法是用一个Map<Thread,T>,如下：

class MockThreadLocal<T> {private Map<Thread, T> map = new HashMap<Thread, T>();public T get() {return (T) map.get(Thread.currentThread());}public void set(T value) {map.put(Thread.currentThread(), value);}}

这样也能实现ThreadLocal的效果，但是有一个问题，当对应的线程消失后，map中对应的线程值并不会被回收，从而造成内存泄露。

 

事实上ThreadLocal是这样做的：

    /**     * 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();    }

注意这里如果取到没有该线程对应的值，会调用setInitialValue();，最终调用initialValue()生成一个值，这也是我们很多场景下要override这个方法的原因；

 

下面看一下getMap(Thread t)方法：

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

在Thread类中：

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

由此可见，所有的ThreadLocal的信息，最终是关联到Thread上的，线程消失后，对应的Thread对象也被回收，这时对应的ThreadLocal对象也会被回收。

这里为什么是一个ThreadLocalMap呢，因为一个线程可以有多个ThreadLocal变量，通过map.getEntry(this)取得对应的某个具体的变量。

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

最后要注意的一点是，ThreadLocalMap的Entry是一个weakReference：

       /**         * 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;            }        }

这里主要因为ThreadLocalMap的key是ThreadLocal对象，如果某个ThreadLocal对象所有的强引用没有了，不能因为ThreadLocalMap的引用导致他不能被回收。

 

 

附：

这里补充一下weakReference的用法供参考（当强引用不存在时，下次垃圾回收会回收弱引用所引用的对象）：

Object o = new Object();WeakReference<Object> ref = new WeakReference<Object>(o);System.out.println(ref.get());o=null;System.gc();System.out.println(ref.get());

结果输出： 

 java.lang.Object@de6ced null