JDK源码之ThreadLocal

1.定义

ThreadLocal是线程变量，就是说每一个线程都有对应的该变量副本，线程修改该变量时，线程与线程之间的变量是相互隔离的，互相并看不见。这个结构附带在线程上，一个线程可以根据ThreadLocal对象查询到绑定到该线程上的值。

2.主要方法

ThreadLocal的主要方法都是基于ThreadLocal的静态内部类ThreadLocalMap进行操作的。

       //map的初始大小为16，必须为2的幂次方
        private static final int INITIAL_CAPACITY = 16;

        //Entry类型的tabel，扩容的时候必须是2的幂次方
        private Entry[] table;

        //table中真实存储的Entry数目
        private int size = 0;

        //阈值大小，当到达阈值大小，要进行扩容操作
        private int threshold; // Default to 0

　　

ThreadLocalMap的主要成员变量：　　　　

可以根据成员变量看出ThreadLocal的table大小始终是2的幂次方，当真实大小达到了阈值，要对table进行扩容。

而table就是主要存放ThreadLocal值的地方，Entry是个啥类型呢？

     static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

Entry类存放了key,value键值对，这里的key是对ThreadLocal的弱应用，value就是值。

ThreadLocalMap的主要方法

       //根据key和value构造一个map，这时map的大小为16，map中只有一个Entry，size为1，阈值也为16
       ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

        //根据key获取Entry
        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);
        }

　　　　　//将key和value添加到map中，如果说key存在，就覆盖value,如果说key是null，被回收，则进行替换老旧的entry，要不然就插入新的entry,并检查是否map大小溢出。

　　　　　//如果说大小超过阈值，则将map进行扩容，并且重新进行rehash
        private void set(ThreadLocal<?> key, Object value) {

            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

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

                if (k == key) {
                    e.value = value;
                    return;
                }

                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }
       /**
         * Double the capacity of the table.
         */
       //扩容时是将容量变为原来的两倍
        private void resize() {
            Entry[] oldTab = table;
            int oldLen = oldTab.length;
            int newLen = oldLen * 2;
            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;
        }

　　

ThreadLocalMap总结：

1.每一个线程都有对应的ThreadLocalMap,在Thead类中有对map的引用

2.ThreadLocalMap的key值是ThreadLocal对象，值就是value值

3.每一个线程不仅仅只有一个ThreadLocal变量，所以map中存储了该线程所有的ThreadLocal变量

4.key值是对ThreadLocal的弱应用，如果这里使用普通的key-value形式来定义存储结构，实质上就会造成节点的生命周期与线程强绑定，只要线程没有销毁，那么节点在GC分析中一直处于可达状态，没办法被回收，而程序本身也无法判断是否可以清理节点。弱引用是Java中四档引用的第三档，比软引用更加弱一些，如果一个对象没有强引用链可达，那么一般活不过下一次GC。当某个ThreadLocal已经没有强引用可达，则随着它被垃圾回收，在ThreadLocalMap里对应的Entry的键值会失效，这为ThreadLocalMap本身的垃圾清理提供了便利。

其实，一直困扰在为啥ThreadLocal为每一个线程都有一个map,这么大的map就存一个ThreadLocal不是很浪费嘛，看源码对map还有扩容的机制，更是不理解，后来发现一个线程不仅仅只使用一个ThreadLocal变量，多个ThreadLocal其实是存放在一个map中。

ThreadLocal主要方法

ThreadLocal主要方法就是set(value)和get()，设置和获取变量的值。

    public void set(T value) {
        //获取当前线程
        Thread t = Thread.currentThread();
        //根据当前线程获取内置的ThreadLocalMap对象，每一个线程都有对应的map
        ThreadLocalMap map = getMap(t);
        //如果map存在，直接向map中添加值
        //如果map不存在，创建属于该线程的map
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

   //为一个线程对象创建ThreadLocalMap对象
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

　在看createMap这个函数的时候，发现将创建的ThreadLocalMap对象是赋值给了Thread的threadlocals，Thread类有成员变量ThreadLocalMap交给ThreadLocal进行维护。

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

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

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

ThreadLocal的get()函数首先获取对应线程的threadLocalMap,再根据ThreadLocal的hash值获取map中的value值。　

3.ThreadLocal导致的内存泄露

为啥ThreadLocalMap中的key要是弱应用？

如果是强引用的话，当线程的ThreadLocal对象被回收了。但是线程有一个成员变量threadlocals是对map的引用，map又对key有强引用，那么key就无法回收，就会每个线程的map越来越大。

但如果是弱引用，当ThreadLocal对象被回收，对key值就会只有一个弱引用，弱引用的对象只能存活到下一次GC的时候。所以key就会被GC,value在get,set和removed的时候也会被回收。

那为啥ThreadLocal依然内存泄露的危险？

value值会存在一条强引用链，当线程存活时，Thread->Thread.threadlocals->ThreadLocalMap->value。

所以只要线程结束了，那么对应的threadLocalMap一定会被回收，不存在内存泄露的风险。

但是要是使用的是线程池，线程存活时间长，那么线程的threadLocalMap也不会被回收，那么就一直会存在一条对value值的强引用，无法回收value，就会造成内存泄露。

在使用线程池和ThreadLocal时，如何避免内存泄露？

在每次使用完ThreadLocal时，便调用ThreadLocal的remove()方法，remove()方法会在map中删除整个entry。

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