理解ThreadLocal和底层实现

一、定义

1. 从jdk的官方文档中的描述：ThreadLocal类是用来提供放线程内部的局部变量，这样变量在多线程环境下访问（通过set和get访问）时能保证各个线程间的变量相对独立于其他线程内的变量。ThreadLocal实例通常来说都是private static 类型的，用来关联线程和线程上下文。
2. 我们可以得知ThreadLocal的作用是提供线程内的局部变量，不同的线程之间不会相互干扰。这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度。
3. 总结：线程并发，传递数据，线程隔离

二、方法

ThreadLocal() ：创建ThreadLocal对象
public void set(T value)：设置当前线程绑定的局部变量
public T get()：获取当前线程绑定的局部变量
public void remove()：移除当前线程绑定的局部变量

三、测试

public class TestDemo1 {
    public String content;

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public static void main(String[] args) {
        TestDemo1 demo1 = new TestDemo1();
        for(int i =0 ;i<5; i++){
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    demo1.setContent(Thread.currentThread().getName()+"的数据");
                    System.out.println("--------------------");
                    System.out.println(Thread.currentThread().getName()+"--->"+demo1.getContent());
                }
            });
            thread.setName("线程"+i);
            thread.start();
        }
    }
}

这里可以发现我们每次去运行main方法后的结果都是不一样的，这就是多线程下的线程安全问题。

下面修改代码用ThreadLocal来保存线程的变量：
public class TestDemo1 {
public String content;

ThreadLocal<String> t1 = new ThreadLocal<>();

public String getContent() {
   // return content;
    return t1.get();
}

public void setContent(String content) {
    //this.content = content;
    t1.set(content);
}

public static void main(String[] args) {
    TestDemo1 demo1 = new TestDemo1();
    for(int i =0 ;i<5; i++){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                demo1.setContent(Thread.currentThread().getName()+"的数据");
                System.out.println("--------------------");
                System.out.println(Thread.currentThread().getName()+"--->"+demo1.getContent());
            }
        });
        thread.setName("线程"+i);
        thread.start();
    }
}

}
结果：

四、比较ThreadLocal和synchronized

	synchronized	ThreadLocal
原理	同步机制采用了‘以时间换空间’的方式，只提供了一份变量各个线程排队访问	采用‘以空间换时间’的方式，为每一个线程都提供一份变量副本，从而实现同时访问而不互相干扰
侧重点	多个线程之间访问资源的同步	多线程中让每个线程的数据相互隔离

总结：我们可以通过测试发现运用同步关键字也可以实现线程的安全，但是两者处理的角度是不一样的，运用同步关键字synchronized 其实就时给访问资源加上了锁，实现了各个线程之间的串行化，大大降低了并发执行的效率，程序运行时间变长。

五、ThreadLocal实现原理

threadLocal.set()方法的源码：
ThreadLocal.java

public void set(T value) {	
		//获取当前线程的map
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
        //以当前的ThreaLocal的引用作为key
            map.set(this, value);
        else
            createMap(t, value);  //创建map
    }

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

void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
 }

Thread.java源码：

ThreadLocal.ThreadLocalMap threadLocals = null;

代码执行流程：

1. 首先获取当前线程，并根据当前线程获取一个map
2. 如果获取的map不为空，则将value值设置到map中（以当前ThreadLocal的引用作为key）
3. 如果map为空，则给该线程创建map,并设置初始值

jdk8的get方法源码 ：

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

代码执行流程：

1. 首先获取当前线程，并根据当前线程获取一个map
2. 如果获取的map不为空，则在map中以ThreadLocal的引用作为key来在对应的map中获取对应的Entry e
3. 如果e不为null,则返回e.value
4. map为空或者e为空，则通过initalValue函数获取初始值value,然后用ThreadLocal的引用和value作为firstkey和firstvalue创建一个map

代码执行流程：先获取当前线程的ThreadLocalMap变量，如果存在则返回值，不存在则创建并返回初始值。

remove()方法源码：

public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

代码执行流程：
首先获取当前线程，并根据当前线程获取一个map
如果获取的map不为空，则移除当前ThreadLocal对象的entry

六、ThreadLocalMap

1. 基本结构
   ThreadLocalMap是ThreadLocal的内部类，没有实现Map接口，用独立的方式实现了Map的功能，其内部的Entry也是独立实现。
   
2. 源码：

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;

        /**
         * The number of entries in the table.
         */
        private int size = 0;

        /**
         * The next size value at which to resize.
         */
        private int threshold; // Default to 0

这里可以看到ThreadLocalMap是ThreadLocal的一个静态内部类。根HashMap类似，成员变量：INITIAL_CAPACITY代表map的初始容量（必须是2的整次幂），table是一个Entry类型的数组用于存储数据，size代表表中的存储数目，threshold代表需要扩容时size的阈值。

3. 存储结构Entry

/**
Entry继承WeakReference，并且用ThreadLocal作为key,
如果key为null（entry.get()==null）,意味着key不在被引用,
因此table也可以从table中删除
**/
static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

总结：

1. 在ThreadLocalMap 中，也是用Entry来保存key-value结构数据的，不过Entry中的key只能是ThreadLocal对象，这点在构造方法中已经限定死了。
2. 另外Entry继承WeakReference弱引用，也就是key(ThreadLocal)是弱引用，其目的是将ThreadLocal的生命周期与线程的生命周期解绑。

七、Entry的key的强弱引用及内存泄漏

强引用（Strong Reference）：就是我们最常见的普通对象引用，只要还有强引用指向一个对象，就表明对象还活着，垃圾回收器就不会回收这种对象（即使堆空间不够用了发生了内存溢出）
软引用(softReference)：在堆空间不够用的时候即使有引用指向对象，该对象也会被回收。
弱引用（weekReference）：垃圾回收器一旦发现只持有弱引用的对象，不管当前内存空间足够与否都会被回收（一看到就回收）
虚引用：(涉及知识比较多暂时不说)

通过源码分析可以知道key的引用是一个弱引用，这里假设如果是强引用会出现怎么样的情况。

1.在业务代码中使用完了ThreadLocalRef,如果ThreadLocalRef这个引用被回收了，还有一个Entry中的key强引用指向了ThreadLocal这个对象，如果不调用remove方法并且当前线程没有结束，那么该强引用一直存在，ThreadLocal对象永远不会被回收导致ThreadLocal对象的内存泄漏。
2.如果不调用remove方法并且当前线程没有结束,强引用链CurrentThreadRef->CurrentThread->ThreadLocalMap->Entry就会一直存在，整个Entry就不会被回收，导致entry内存泄漏。

源码中的key是弱引用的情况：

1. 同样在业务代码中使用完了ThreadLocalRef,如果ThreadLocalRef这个引用被回收了
2. 这时候指向ThreaLocal持有的引用只有key的一个弱引用，没有任何强引用指向ThreadLocal实例，ThreadLocal对象就可以顺利被GC回收，这时候key的弱引用就指向了null即key==null
3. 但是这时候如果没有手动remove删除Entry且线程没有结束，仍然存在强引用链CurrentThreadRef->CurrentThread->ThreadLocalMap->Entry->value,value不会被回收，也不会被访问到导致value内存泄漏

总结以上：
4. 即使Entry.key使用弱引用也会出现value的内存泄漏，只不过不会出现ThreadLocal对象的内存泄漏
5. 内存泄漏的真实原因：
1.没有手动remove()删除Entry；
2.当前线程仍在运行 ；(ThreadMap是Thread的一个属性被当前线程所引用，所以他的生命周期根Thread一样长，那么在使用完ThreadLocal之后如果线程也随之结束，ThreadLocalMap自然也会被被GC回收，从而在根源上避免了内存泄漏)
综上：ThreadLocal内存泄漏的根源：由于ThreadLocalMap的生命周期根Thread一样长，如果没有手动删除对应key就会导致内存泄漏。
3. 使用弱引用的原因：
使用完ThreadLocal，但是Thread仍然运行的情况下，就算忘记了调用remove()方法，弱引用可以比强引用多一层保障：弱引用的ThreadLocal会被回收，对应的value在下一次ThreadLocalMap调用set,get,remove中的人一方法的时候会被清除，从而避免内存泄漏。