java中的reference(四): WeakReference的应用--ThreadLocal源码分析

[toc]
实际上，在分析整个Reference包源码之前，重点关注的问题就是ThreadLocal的源码。这也是学习Reference这个系列的初衷。一开始的想法就是将ThreadLocal源码好好理解一遍。毕竟这这也是目前大多数大厂面试的高频考点。但是在打开ThreadLocal之后，发现最关键的是巧妙应用了WeakReference。虽然ThreadLocal的其他代码的巧妙程度也让人印象深刻。但是ThreadLocal绝对称得上WeakReference的经典应用，没有之一。面试必问。要想搞明白ThreadLocal必须弄清楚WeakReference。这也是这个Reference的动机之一。学习就是如此，从一个点逐渐衍生到一个面。那么看了weakReference，就会自然的看Reference的各个子类。包括在上一篇，对FinalReference的分析，这都是之前没有重点关注的冷门知识点。那么现在能放到一个整体去分析，也是一个值得高兴的事情。

1.ThreadLocal的使用

1.1 threadlocal 运行示例

看如下示例代码，我们有两个线程，a和b,线程a启动之后，sleep 2秒，从threadlocal t1中取获取person实例 p，线程b，启动之后，sleep 1秒，然后set Person的实例p到threadlocal t1中去。

    volatile static Person p = new  Person();

    static ThreadLocal t1 = new ThreadLocal<>();


    public static void main(String[] args) {
        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(" thread a "+t1.get());
        }).start();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            t1.set(new Person());
            System.out.println(" thread b "+t1.get());
        }).start();
    }

    static class Person {
        String name;
    }

运行代码结果如下：

 thread b com.dhb.test.ThreadLocal1$Person@5058a2e0
 thread a null

Process finished with exit code 0

可以看到，thread b能获取到p,而thread a不能。这就证明了threadlocal的主要功能。threadlocal提供了一个对线程隔离的局部变量载体。

1.2 threadlocal的主要功能

可以看一下threadlocal中源码的注释：

/**
 * This class provides thread-local variables.  These variables differ from
 * their normal counterparts in that each thread that accesses one (via its
 * {@code get} or {@code set} method) has its own, independently initialized
 * copy of the variable.  {@code ThreadLocal} instances are typically private
 * static fields in classes that wish to associate state with a thread (e.g.,
 * a user ID or Transaction ID).
 *
 * 
For example, the class below generates unique identifiers local to each
 * thread.
 * A thread's id is assigned the first time it invokes {@code ThreadId.get()}
 * and remains unchanged on subsequent calls.
 * 
 * import java.util.concurrent.atomic.AtomicInteger;
 *
 * public class ThreadId {
 *     // Atomic integer containing the next thread ID to be assigned
 *     private static final AtomicInteger nextId = new AtomicInteger(0);
 *
 *     // Thread local variable containing each thread's ID
 *     private static final ThreadLocal<Integer> threadId =
 *         new ThreadLocal<Integer>() {
 *             @Override protected Integer initialValue() {
 *                 return nextId.getAndIncrement();
 *         }
 *     };
 *
 *     // Returns the current thread's unique ID, assigning it if necessary
 *     public static int get() {
 *         return threadId.get();
 *     }
 * }
 * 
 * 
Each thread holds an implicit reference to its copy of a thread-local
 * variable as long as the thread is alive and the {@code ThreadLocal}
 * instance is accessible; after a thread goes away, all of its copies of
 * thread-local instances are subject to garbage collection (unless other
 * references to these copies exist).
 *
 * @author  Josh Bloch and Doug Lea
 * @since   1.2
 */

大意为，在jdk1.2版本之后，jdk提供了一个基于线程隔离的线程本地变量。每个访问的get和set方法的线程都有自己独立的变量副本。threadlocal的实例通常会设置为private static 类型，以便将一些状态和某个线程关联。（如用户编号和事务ID）。
然后提供了一个基于AtomicInteger 的demo。
对于一个threadlocal对象，每个线程在存活的周期内都保留了一个对该对象的隐式引用，这个ThreadLocal可以进行数据存取。当线程死亡的时候，线程中的所有threadLocal对象都会被GC回收（除非有其他对ThreadLocal的引用任然存在）。
这就是threadlocal的主要功能。这个功能主要用在什么地方呢？实际上，可能我们每天都在用，但是你并没有关注到而已。在spring中，基于数据库事务的的调用，spring使用连接池连接数据库，又需要在CRUD操作中把多个代码中的操作放到一个事务中的话，那么最好的办法就是，让连接与spring的线程绑定，这个线程的所有crud操作最终都在一个connection上commit。这自然可以实现这些需求，这也是spring面试的高频考点。

1.3 threadlocal提供的主要api

threadLocal的public方法表如下：

image.png

可以看到，除了构造函数之外，ThreadLocal的主要方法有，get、set、remove和基于lambda的withInitial方法。

1.3.1 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) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        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;
    }

可以看到，ThreadLocal内部维护了一个特殊的HashMap,这个Map存在当前线程（Thread.currentThread()）的threadLocals参数中，以当前的ThreadLocal为key。通过当前threadLocal去Map中获取Entry。这个特殊的Map就是ThreadLocalMap。通过getmap方法可以知道，这个Map实际上就维护在Thread对象中。属性为threadLocals。

1.3.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);
    }
    
    /**
     * 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
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    

通过set方法的源码，我们可以看到，在set的时候，首先判断map是否为null，如果为null则调用creatMap方法，以当前传入的value创建一个以当前ThreadLocal为key的新的map。这个把当前线程的threadLocals 指向这个map。
而InheritableThreadLocal，则会对createMap重写，以实现可继承的在子类中共享的ThreadLocal。
因此可以知道，每个线程都有一个固定的threadLocals属性，这个属性指向一个ThreadLocalMap。

1.3.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
     * {@code initialValue} method in the current thread.
     *
     * @since 1.5
     */
     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

remove方法主要是从当前线程的ThreadLocalMap中将ThreadLocal为key的Entry移除。对于Threadlocal,如果使用完毕，则务必调用remove方法移除，以避免引起内存泄漏或者OOM。后面会对这个问题做详细分析。

1.3.4 withInitial

    /**
     * Creates a thread local variable. The initial value of the variable is
     * determined by invoking the {@code get} method on the {@code Supplier}.
     *
     * @param  the type of the thread local's value
     * @param supplier the supplier to be used to determine the initial value
     * @return a new thread local variable
     * @throws NullPointerException if the specified supplier is null
     * @since 1.8
     */
    public static  ThreadLocal withInitial(Supplier supplier) {
        return new SuppliedThreadLocal<>(supplier);
    }

这个withInitial方法是jdk1.8之后专门给lambda方式使用的的构造方法。这个方法采用Lambda方式传入实现了 Supplier 函数接口的参数。如下：

ThreadLocal balance = ThreadLocal.withInitial(() -> 1000);

这样即可用lambda的方式进行调用。

2.ThreadLocal核心源码及其与Weakreference的关系

2.1 ThreadLocalMap结构

ThreadLocal的核心部分就是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> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

可以看到，注释中说得非常明白，ThreadLocalMap是一个特定的hashMap,只适用于ThreadLocal，private修饰，做为threadLocal的内部类，无法在其他地方访问到。这个ThreadLocalMap的Entry继承了WeakReference，用以实现对value对象的长期缓存。但是，由于用户不能直接操作ReferenceQueue,而WeakReference与Key的绑定，key是ThreadLocal自身，那么Entry到Key之间就是弱引用的关系，因此，只有GC的时候这些过期不用的entry才会被删除。当entry.get()方法为null的时候，表示这个entry是过时的。

2.2 ThreadLocalMap与WeakReference的关系

从上文中可以看到，ThreadLocalMap的Entry是WeakReference的，那么，当对这个Entry中的强引用消失之后，weakReference就会被GC回收。

ThreadLocal a = new ThreadLocal();
a.set(new byte[1024*1024*10]);

以上述代码为例，其内存布局如下：

image.png

如上图所示，如果定义了一个ThreadLocal，那么在Stack上就会有两个指针，分别指向ThreadLocal和当前线程在堆上的内存地址。之后，当前的线程中的threadLocals指向这个ThreadLocalMap,而Map中的Entry，包括Key和Value，Key又通过WeakReference的方式指向了ThreadLocal。Value即是当前需要放在ThreadLocal中的值。可能是一个大的对象，以供线程内部共享。因此value强引用指向了这个value内容。
此时不难发现一个问题，就是当ThreadLocal的强引用一旦消失之后，如申明一个threadLocal变量a,此时令a=null,那么之前的threadlocal就会被GC回收。

ThreadLocal a = new ThreadLocal();
a.set(new byte[1024*1024*10]);
a = null;

此时，如果a=null,那么后面如果执行GC，会导致a被回收，而ThreadLocalMap中，这个a对应的Entry的key就会变成null，而value为10MB,并不会在这次GC中回收。这也是threadLocal可能会造成内存泄漏的原因。因此，如果有threadlocal不需要使用之后，最好的办法是使用remove将其从ThreadLocalMap中移除。

2.3 ThreadLocalMap的核心源码

我们再来详细看看ThreadLocalMap，这个关键的类，使用了很多脑洞大开的设计，值得我们在以后的编码中进行借鉴。

2.3.1 基本组成元素 Entry

    /**
         * 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> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

Entry是ThreadLocalMap的核心，也是应用WeakReference的地方。Entry本身继承了WeakReference。之后将传入的ThreadLocal也就是key，放在了WeakReference中，这样构成了对key的WeakReference,而value则是Entry的属性，对value的指针是强引用。
其结构如下图：

image.png

引用关系如下：

image.png

2.3.2 构造函数

ThreadLocal有两个主要的构造函数，分别是创建的时候插入一个Entry和批量插入Entry构造。

2.3.2.1 ThreadLocalMap(ThreadLocal firstKey, Object firstValue)

这个构造函数在使用的时候需要传入第一个key和value。ThreadLoccalMap底层的hash表的长度初始为INITIAL_CAPACITY = 16。
这个构造函数的作用域在protected。

     /**
         * The initial capacity -- MUST be a power of two.
         */
        private static final int INITIAL_CAPACITY = 16;
 /**
         * Construct a new map initially containing (firstKey, firstValue).
         * ThreadLocalMaps are constructed lazily, so we only create
         * one when we have at least one entry to put in it.
         */
        ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
            //初始hash表，长度为16
            table = new Entry[INITIAL_CAPACITY];
            //Hash取模运算，计算index
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            //根据hash取模得到索引位置，然后构建Entry
            table[i] = new Entry(firstKey, firstValue);
            //维护长度变量，初始为1
            size = 1;
            //设置负载因子
            setThreshold(INITIAL_CAPACITY);
        }

该方法主要配合ThreadLocal中的createMap方法使用。ThreadLocal是采用懒加载的方式，在需要的时候才会创建ThreadLocalMap,由于每个thread都有一个threadlocals来存储对应的ThreadLocalMap,不存在共享问题，因此是线程安全的，不需要加锁。
首先创建INITIAL_CAPACITY大小的Entry数组。之后将firstKey的threadLocalHashCode和(INITIAL_CAPACITY - 1)取模。之后构造一个Entry传入这个hash表计算的index处。然后对于hash表的长度，size是动态计算的，初始为1，后续每次增减会用维护的这个size变量增减。如下图：

image.png

另外还维护的负载因子threshold，是len的2/3，当size大于这个值就开始扩容。

  /**
         * Set the resize threshold to maintain at worst a 2/3 load factor.
         */
        private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }

2.3.2.1 ThreadLocalMap(ThreadLocal firstKey, Object firstValue)

批量构造，这种情况发生在InheritableThreadLocal的时候，一个子类要将父类全部的ThreadLocalMap继承，则会使用这个构造函数。除此之外ThreadLocal种不会用到这个构造函数。另外这个构造函数也是private的。不提供给用户访问。仅仅在createInheritedMap方法中调用。

        /**
         * Construct a new map including all Inheritable ThreadLocals
         * from given parent map. Called only by createInheritedMap.
         *
         * @param parentMap the map associated with parent thread.
         */
        private ThreadLocalMap(ThreadLocalMap parentMap) {
            //拿到父类种的table及其长度
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            //根据父类长度设置负载因子
            setThreshold(len);
            //根据父类长度创建相同大小的hash表
            table = new Entry[len];
            //遍历赋值
            for (int j = 0; j < len; j++) {
               //通过entry判断是否为空，不为空则构造一个新的Entry
                Entry e = parentTable[j];
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    //拿到key
                    ThreadLocal