ThreadLocal和InheritableThreadLoc

ThreadLocal

概述

ThreadLocal一般称为线程本地变量，它是一种特殊的线程绑定机制，将变量与线程绑定在一起，为每一个线程维护一个独立的变量副本，每个线程的私有变量。通过ThreadLocal可以将对象的可见范围限制在同一个线程内。

一个误区

不要将synchronized与ThreadLocal进行对比，sysnchronized是一种互斥同步机制，是为了保证在多线程环境下对于共享资源的正确访问。而ThreadLocal是提供一个“线程级”的变量作用域（线程内的static变量），它是一种线程封闭（每个线程独享变量）技术，更直白点讲，ThreadLocal可以理解为将对象的作用范围限制在一个线程上下文中，使得变量的作用域为“线程级”。

再简单点总结，Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。

没有ThreadLocal的时候，一个线程在其生命周期内，可能穿过多个层级，多个方法，如果有个对象需要在此线程周期内多次调用，且是跨层级的（线程内共享），通常的做法是通过参数进行传递；而ThreadLocal将变量绑定在线程上，在一个线程周期内，无论“你身处何地”，只需通过其提供的get方法就可轻松获取到对象。极大地提高了对于“线程级变量”的访问便利性。

用法：

一般把ThreadLocal变量作为单独的public static变量

通过set(...)存入数据，通过get()获取数据

解决get返回null问题

第一次使用get都会返回null，可以继承Threadlocal再覆盖initialValue方法可以解决

private static final ThreadLocal<Integer> threadId = 
    new ThreadLocal<Integer>(){
       @Override
       protected Integer initialValue(){
           return 1;
       }
    }

看看set源码

public void set(T value) {
    Thread t = Thread.currentThread()   //首先获取当前线程对象
    ThreadLocalMap map = getMap(t);     //获取该线程对象的ThreadLocalMap
    if (map != null)
        map.set(this, value);
        //如果map不为空，执行set操作，以当前threadLocal对象为key，实际存储对象为value进行set操作
    else
        createMap(t, value);            //如果map为空，则为该线程创建ThreadLocalMap
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;              //线程对象持有ThreadLocalMap的引用
}

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

从上面代码可以看出来，ThreadLocal是通过在Thread里面保存了一个ThreadLocalMap才产生了全局线程私有变量，在Thread中，也确实有这么一行

ThreadLocal.ThreadLocalMap threadLocals = null;

这样子就大概知道ThreadLocal的设计思路了：

1. ThreadLocal作为变量访问的入口
2. 每个Thread含有一个ThreadLocalMap对象，这个ThreadLocalMap持有对象的引用
3. ThreadLocalMap以当前的threadlocal对象为key，以真正的存储对象为value。get时通过threadlocal实例就可以找到绑定在当前线程上的对象。

看上去似乎变为Map<Thread,T>这种形式会自然些，一个线程对应一个存储对象。ThreadLocal这样设计的目的主要有两个：

1. 保证当前线程结束时相关对象能尽快被回收，把value放在了线程当中，这样线程死亡，value随之回收
2. ThreadLocalMap中的元素会大大减少，而map过大更容易造成哈希冲突而导致性能变差

get源码

public T get() {
    Thread t = Thread.currentThread();  //首先获取当前线程
    ThreadLocalMap map = getMap(t);     //获取线程的map对象
    if (map != null) {      //如果map不为空，以threadlocal实例为key获取到对应Entry，然后从Entry中取出对象即可。
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null)
            return (T)e.value;
    }
    return setInitialValue();
    //如果map为空，也就是第一次没有调用set直接get（或者调用过set，又调用了remove）时，为其设定初始值
}

private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

关于ThreadLocal的使用问题

如果我们为一个线程关联的对象是“完全独享”的，也就是每个线程拥有一整套的新的栈中的对象引用+堆中的对象，那么这种情况下是真正的线程独享变量”，相当于一种深度拷贝，每个线程自己玩自己的，对该对象做任何的操作也不会对别的线程有任何影响。（对于对象过大的时候，如果每个线程有一个深拷贝，开销很大）

另一种更普遍的情况，所谓的独享变量副本，其实也就是每个线程都拥有一个独立的对象引用，而堆中的对象还是线程间共享的，这种情况下，自然还是会涉及到对共享资源的访问操作，依然会有线程不安全的风险。所以说，ThreadLocal无法解决线程安全问题。

为何threadLocals的类型ThreadLocalMap的键值为ThreadLocal对象，因为每个线程中可有多个threadLocal变量

另外还有一个坑

当使用不当时，其作用域范围使用者可能不明确。

解释一下：线程如果运行完，也就是run方法执行完了，线程注销，ThreadLocal被回收；可是，还有一种更加常见的情况，线程池！线程可能不会立马注销，也就是ThreadLocal不会被回收，如果ThreadLocal中包装了集合类或复杂对象，那内部集合类和复杂对象锁占用的内存可能会膨胀

使用ThreadLocal的场景

最常见的ThreadLocal使用场景为 用来解决 数据库连接、Session管理等。

以Spring为例，Spring的事务管理器通过AOP切入业务代码，在进入业务代码前，会依据相应的事务管理器提取出相应的事务对象，假如事务管理器是DataSourceTransactionManager，就会从DataSource中获取一个连接对象，通过一定的包装后将其保存在ThreadLocal中。而且Spring也将DataSource进行了包装，重写了当中的getConnection()方法，或者说该方法的返回将由Spring来控制，这样Spring就能让线程内多次获取到的Connection对象是同一个。通过将连接对象保存在线程内部，不论什么时候都能拿到，此时Spring很清楚什么时候回收这个连接，也就是很清楚什么时候从ThreadLocal中删除这个元素

再来看看InheritableThreadLocal

作用：

显然，在原本的ThreadLocal使用上，如果父线程创建了子线程，父线程是没办法把当前拥有的ThreadLocal传递给子线程的，为何，在get()可以看得到，

public T get() {
    Thread t = Thread.currentThread();  //首先获取当前线程
    ThreadLocalMap map = getMap(t); 
    if (map != null) { 
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null)
            return (T)e.value;
    }
    return setInitialValue();
}

第一步获取当前线程，而当前线程为子线程，子线程有自己的ThreadLocalMap，跟父线程毫无关系，这个地方可以从2点佐证：1. ThreadLocal的目的是为了使得每个线程有自己的独立私有变量

2. Thread的创建会调用init(...)，当中不会为子线程继承ThreadLocal（这里详细可见Thread的init()函数）

而有些时候需要使得父线程的一些变量继承给子线程，这时候就出现了InheritableThreadLocal，

原理

用法跟ThreadLocal一样，所以就只讲讲InheritableThreadLocal的实现，直接上源码

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    protected T childValue(T parentValue) {
        return parentValue;
    }
    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

看样子，这里的关键在于getMap这个地方，由于是继承，所以会使用覆盖的方法，原本的getMap(Thread t)是长这样的

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

只是返回的map不同，InheritableThreadLocal返回的map是从父线程继承下来的，但这是在什么时候设置的？最重点的地方到了，就是在每个Thread创建的时候都会调用的init()方法，这里只贴出跟

private void init(ThreadGroup g, Runnable target, 
            String name, long stackSize, AccessControlContext acc) {
    ......    
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)        
        this.inheritableThreadLocals = 
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    ......    
}

来到了ThreadLocal的方法

static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
    return new ThreadLocalMap(parentMap);       //这里把parentMap给复制了一遍
}

到此

参考：

http://www.cnblogs.com/dolphin0520/p/3920407.html
https://blog.csdn.net/ni357103403/article/details/51970748