线程应用：（十）ThreadLocal

一、应用场景举例

　　每个线程都应该有自己的数据库连接Connection，不能被其他线程所影响，就可以使用ThreadLocal（一个线程内各模块间共享同一数据，各线程间的数据又是独立的）。

二、使用举例

　　线程范围内的共享变量，每个线程有自己独立的数据。例如每个线程要有自己独立的连接。ThreadLocal本质上是一个map。

　　只要定义一个ThreadLocal变量，往这个变量里放的数据就是和线程相关的。一个ThreadLocal只能放一个变量，如果要存多个变量可以利用实体类。结合单例模式，把ThreadLocal定义在实体类。

public class ThreadTest4 {
    public static void main(String[] args){
        for(int i=0;i<2;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    int data = new Random().nextInt();
                    System.out.println(Thread.currentThread().getName()+"has put data:" + data);
                    Entity.getInstance().setData(data);        //拿到本线程在这个类里对应的实例，再赋值
                    new A().get();
                    new B().get();
                }
            }).start();
        }
    }
}

class A {
    public void get(){
        Entity mydata = Entity.getInstance();
        System.out.println("A from "+Thread.currentThread().getName()+"has put data:" + mydata.getData());
    }
}

class B {
    public void get(){
        Entity mydata = Entity.getInstance();
        System.out.println("B from "+Thread.currentThread().getName()+"has put data:" + mydata.getData());
    }
}

//多变量实体类
class Entity{
    private Entity(){}
    private static ThreadLocal<Entity> map = new ThreadLocal<Entity>();    //在这个类中定义一个ThreadLocal，存每个线程对应的实例
    public static /*synchronized*/ Entity getInstance(){    //一般单例加synchronized会更严谨一点，这里取的就是本线程的实体类，所以可不加
        Entity instance = map.get();
        if(instance == null){        //如果这个线程还没有对应的实例，才往ThreadLocal存
            instance = new Entity();
            map.set(instance);        
        }
        return instance;
    }
    int data;
    public int getData() {
        return data;
    }
    public void setData(int data) {
        this.data = data;
    }
}

运行结果：
Thread-0has put data:2114567887
Thread-1has put data:-746942766
A from Thread-1has put data:-746942766
A from Thread-0has put data:2114567887
B from Thread-0has put data:2114567887
B from Thread-1has put data:-746942766

三、源码分析

1、get()方法

//ThreadLocal的get()方法
public T get() {
    Thread t = Thread.currentThread();        //1、得到当前线程
    ThreadLocalMap map = getMap(t);            //2、从当前线程获得threadLocals成员变量
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);    //3、从threadLocals得到对应线程数据
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

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

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

　　看完了get()方法，我发现ThreadLocal和我想象的不一样，我一开始以为ThreadLocal本身就是一个map数据结构，键是线程id，但其实真正存储数据的地方是在每个Thread对象的 threadLocals属性中，threadLocals 属性是一个 ThreadLocal.ThreadLocalMap 对象。并且通过ThreadLocal的threadLocalHashCode指定数据存储在数组的哪个位置下。

　　可能接下来就有疑问：ThreadLocalMap的数据结构是怎么样的？又是怎么存储数据的呢？

2、ThreadLocalMap数据结构

//Thread类的成员变量threadLocals
public class Thread implements Runnable {
...    
    ThreadLocal.ThreadLocalMap threadLocals = null;
...

　　

//ThreadLocal.ThreadLocalMap
static class ThreadLocalMap {

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

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

    private static final int INITIAL_CAPACITY = 16;

    private Entry[] table;

...

　　ThreadLocal.ThreadLocalMap 是 ThreadLocal 的一个静态内部类。可以看出，ThreadLocalMap实际是使用一个数组 private Entry[] table 来存储数据，初始大小为16，类型为Entry。

 　　对于Entry类型，一开始我看 Entry 只有一个value属性，就有一个疑问，为什么 Entry[] table 这个数组是一个map数组，而不是value数组。更仔细地查看源码后，发现Entry真的应该是一个键值对数组，并以 ThreadLocal<?>作为key，且这个key被弱引用类型包装 WeakReference<ThreadLocal<?>>。从ThreadLocalMap 的 getEntry() 方法可以看出进行了一次key的比对，而这里的key就是Entry的referent属性，且referent被一个弱引用包装。

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

public T get() {
    return this.referent;
}

　　综上，我们知道，ThreadLocal 并不是真正存放数据的数据结构，而是被弱引用包装，做为每个线程Thread对象中ThreadLocalMap类型属性的key。

　　为什么不是把ThreadLocal当成map，以线程ID为key这样的方式，而是以这样的方式来存放数据，其实思考一下，是能发现其可取之处的，对于后一种方式，当线程结束后，相关的数据会跟随一起被回收。如果把ThreadLocal当成map，理论上也能实现，但就可能会出现线程结束但它的相关资源仍存在的情况。 

3、set()方法

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);    //根据threadLocalHashCode找数组中对应的位置

    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();

        if (k == key) {                //看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();
}

四、ThreadLocal内存泄漏的问题

　　根据上面Entry方法的源码，我们知道ThreadLocalMap是使用ThreadLocal的弱引用作为Key的。JVM中弱引用在垃圾回收时，不管内存有没有占满，都会被GC回收。因此很有可能在某次GC之后，某个线程的某个ThreadLocal变量变成了null，那么在Entry中，Key也变成了null，在查找时将永远不会被找到，这个Entry的Value将永远不会被用到，这就是内存泄漏。　

为了防止此类情况的出现，我们有两种手段。

　　1、手动调用ThreadLocal的remove函数，手动删除不再需要的ThreadLocal，防止内存泄露；

　　2、JDK建议ThreadLocal定义为private static，这样ThreadLocal的弱引用问题则不存在了。

　　

参考链接：

 http://www.cnblogs.com/digdeep/p/4510875.html

 https://www.cnblogs.com/qiuyong/p/7091689.html

 http://www.importnew.com/22039.html

 https://blog.csdn.net/lhqj1992/article/details/52451136

https://blog.csdn.net/fly910905/article/details/78869251

https://www.cnblogs.com/xzwblog/p/7227509.html

https://www.cnblogs.com/coshaho/p/5127135.html

https://www.cnblogs.com/dolphin0520/p/3920407.html

http://blog.51cto.com/2179425/2082743

https://blog.csdn.net/woshiluoye9/article/details/72544764

https://blog.csdn.net/L_BestCoder/article/details/79252620