ThreadLocal缺点及解决方案

简单的一句话总结是每个Thread上都有一个threadLocals属性，它是一个ThreadLocalMap，里面存放着一个Entry数组，key是ThreadLocal类型的弱引用，value是对用的值。所有的操作都是基于这个ThreadLocalMap操作的。但是它有一个局限性，就是不能在父子线程之间传递。 即在子线程中无法访问在父线程中设置的本地线程变量。 后来为了解决这个问题，引入了一个新的类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、createMap方法。
Thread类中有两个重要的变量

    ThreadLocal.ThreadLocalMap threadLocals = null;
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

# init()方法片段
Thread parent = currentThread(); 
.....
if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

子线程时通过在父线程调用new Thread()方法来创建子线程，Thread#init方法在Thread的构造方法中被调用。主要是先获取当前线程对象，即待创建的线程的父线程
如果父线程的inheritableThreadLocals不为空，并且inheritThreadLocals为true(默认为true),则使用父线程的ingerit本地变量的值来创建子线程的inheritableThreadLocals结构，即将父线程中的本地变量复制到子线程中。

private Entry[] table;

private ThreadLocalMap(ThreadLocalMap parentMap) {
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            setThreshold(len);
            table = new Entry[len];

            for (int j = 0; j < len; j++) {
                Entry e = parentTable[j];
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
                    if (key != null) {
                        Object value = key.childValue(e.value);
                        Entry c = new Entry(key, value);
                        int h = key.threadLocalHashCode & (len - 1);
                        while (table[h] != null)
                            h = nextIndex(h, len);
                        table[h] = c;
                        size++;
                    }
                }
            }
        }

子线程默认拷贝父线程的方式是浅拷贝，如果需要使用深拷贝，如果需要使用深拷贝，需要使用自定义ThreadLocal，继承InheritThreadLocal并重写childValue方法。

而它的实现原理主要是在创建子线程时将父类线程中的本地变量值parent.inheritableThreadLocals复制到子线程，即复制的机会在创建子线程时。

但是它也有一种缺陷，就是在使用线程池的情况下，因为线程池是复用线程，不会重复创建，而上述的inheritableThreadLocals是在创建子线程时才会将父线程的值复制到子线程，但是在线程池中不会重复创建，所以多次使用后，仍然记录的是第一次提交任务时的外部线程的值，造成了数据的错误。

那如何解决这种现象呢？

只需在用户线程向线程池提交任务时复制父线程的上下文环境，就可以实现本地变量在线程池调用的透传。 基于这个思想，阿里提出了TransmittableThreadLocal类。

 

 

在提交任务时的Runable或者Callable必须封装成TtlRunable或者TtlCallable。

TransmittableThreadLocal覆盖实现了ThreadLocal的set、get、remove，实际存储inheritableThreadLocal值的工作还是inheritableThreadLocal父类完成，TransmittableThreadLocal只是为每个使用它的Thread单独记录一份存储了哪些TransmittableThreadLocal对象。

public final void set(T value) {
  super.set(value);
  if (null == value) removeValue();
  else addValue();
}

首先它会调用父类的InheritableThreadLocal的set方法，将value加入到Thread对象的inheritableThreadLocals变量中。
如果value为null，则调用removeValue()方法，否则调用addValue方法。

private void addValue() {
    if (!holder.get().containsKey(this)) {    // @1
        holder.get().put(this, null); // WeakHashMap supports null value.
    }
}
private void removeValue() {
    holder.get().remove(this);
}

调用addValue方法，会将当前ThreadLocal存储到TransmittableThreadLocal的全局静态变量hodler。所有和Thread绑定的所有TransmittableThreadLocal对象都保存在这个holder中，holder只是为了记录当前Thread绑定了哪些TransmittableThreadLocal对象。

下面具体讲一下TtlRunable的原理。

private TtlRunnable(@Nonnull Runnable runnable, boolean releaseTtlValueReferenceAfterRun) {
    this.capturedRef = new AtomicReference<Object>(capture());   
    this.runnable = runnable;
    this.releaseTtlValueReferenceAfterRun = releaseTtlValueReferenceAfterRun;
}

先创建Map容器，用来存储父线程的本地线程变量，键为在父线程执行过程中的TransmittableLocal线程；将线程中的值存放在里面。默认是浅拷贝，需要深拷贝的话，要重写copyValue方法。

public void run() {
     Object captured = capturedRef.get();             
     if (captured == null || releaseTtlValueReferenceAfterRun && !capturedRef.compareAndSet(captured, null)) {
         throw new IllegalStateException("TTL value reference is released after run!");
   }
     Object backup = replay(captured);            
     try {
         runnable.run();                                           
    } finally {
        restore(backup);                                       
    }
}

TtlRunable是实现于Runable，所以线程池执行的是TtlRunable，但是在TtlRunnable run方法中国会执行Runable run方法。

TtlRunable构造方法中，调用了capture()获取当前线程中所有的上下文，并存储在AtomicReference中。

当线程执行时，调用TtlRunable run方法， TtlRunable会从AtomicReference中获取出调用线程中的上下文，并把上下文利用replay方法把上下文复制到当前线程，并把上下文备份。

当线程执行完，调用restore把备份的上下文传入，恢复备份的上下文传入，把后面新增的上下文删除，并重新把上下文复制到当前线程。本次执行并不会污染线程池中线程原先的上下文环境。