ThreadLocal详解

作用：提供线程内的局部变量，不同线程之间不会相互干扰，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度。

主要方法：

• ThreadLocal.set() 用于绑定变量到当前线程
• ThreadLocal.get() 用于取出绑定的变量
• ThreadLocal.remove() 用于移除绑定的变量

	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();
    }
    
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            map.set(this, value);
        } else {
            createMap(t, value);
        }
    }
    
    public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null) {
             m.remove(this);
         }
     }
     
	ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

Synchronized和ThreadLocal区别：

• Synchronized使用时间换空间，只提供一份变量，让不同线程排队访
• ThreadLocal使用空间换时间，为每一个线程提供一份变量副本，从而相互不干扰
• Synchronized侧重点是多线程之间访问资源的同步
• ThreadLocal侧重点是多线程中每个线程之间的数据相互隔离。

相同点：两者都是用于处理多线程并发访问变量问题

内部原理：
源码来自于JDK1.8

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

参照上面的源码发现：set方法实际是调用map的set方法；map.set(this, value);
将ThreadLocal，和传的value设置进去。
每一个Thread维护了一个ThreadLocalMap，这个map的key是ThreadLocal本身，value是要存储的的值Object。
早期的map设置的key是Thread线程对象，value是要存储的值。由ThreadLocal维护Thread

为什么要这么改变？

1. map中维护的entry节点数量变少了
2. 当Thread销毁的时候，ThreadLocalMap也会随之销毁，减少了内存的使用

可以发现上面的ThreadLocalMap是继承虚引用。虚引用是不管是否引用都要进行GC处理内存。
ThreadLocal内存泄露的根本原因：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key就会导致内存泄露。
如何处理：当使用完就要调用remove方法将变量解绑。