JavaThreadLocal

多线程访问同一个共享变量时特别容易出现并发问题，特别是在多个线程需要对
共享变量进行写入时。为了保证线程安全，一般使用者在访问共享变量时需要进行适当的同步。
同步的措施一般是加锁，这就需要使用者对锁有一定的了解，这显然加重了使用者的负担。那么有没有一种方式可以做到，当创建一个变量后，每个线程对其进行访问的时候访问的是自己线程的变量呢？其实 ThreadLocal就可以做这件事情，虽然 ThreadLocal并不是为了解决这个问题而出现的。

ThreadLocal是JDK包提供的，它提供了线程本地变量，也就是如果你创建了
ThreadLocal ，那么访问这个变量的每个线程都会有这个变量的一个本地副本。当多个线程操作这个变量时，实际操作的是自己本地内存里面的变量，从而避免了线程安全问题。创建ThreadLocal变量后，每个线程都会复制一个变量到自己的本地内存。

Threadlocal 的实现原理

Thread类中有一个threadLocals和一个inheritableThreadLocals，它们都是ThreadLocalMap类型的变量，而ThreadLocalMap是一个定制化的Hashmap。在默认情况下，每个线程中的这两个变量都为null ，只有当前线程第一次调用ThreadLocal的set方法时才会创建它们。其实每个线程的本地变量不是存放在ThreadLocal实例里面，而是存放在调用线程的threadLocals变量里面。也就是说 ThreadLocal 类型的本地变量存放在具体的线程内存空间中。ThreadLocal就是一个工具壳，它通过 set 方法把 value 值放入调用线程的threadLocals里面并存放起来，当调用线程调用它的get时，再从当前线程的threadLocals变量里面将其拿出来使用。如果调用线程一直不终止， 那么这个本地变量会一直存放在调用线程的threadLocals里面 ，所以当不需要使用本地变量时可以通过调用ThreadLocal变量的remove方法 ，从当前线程的threadLocals里面删除该本地变量。另外， Thread里面threadLocals为何被设计为 map 结构？很明显是因为每个线程可以
联多个ThreadLocal变量。

get丶set丶remove方法

/**
 * Returns the value in the current thread's copy of this
 * thread-local variable.  If the variable has no value for the
 * current thread, it is first initialized to the value returned
 * by an invocation of the {@link #initialValue} method.
 *
 * @return the current thread's value of this thread-local
 */
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();
}

/**
 * Variant of set() to establish initialValue. Used instead
 * of set() in case user has overridden the set() method.
 *
 * @return the initial value
 */
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;
}

/**
 * Sets the current thread's copy of this thread-local variable
 * to the specified value.  Most subclasses will have no need to
 * override this method, relying solely on the {@link #initialValue}
 * method to set the values of thread-locals.
 *
 * @param value the value to be stored in the current thread's copy of
 *        this thread-local.
 */
public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

/**
 * Removes the current thread's value for this thread-local
 * variable.  If this thread-local variable is subsequently
 * {@linkplain #get read} by the current thread, its value will be
 * reinitialized by invoking its {@link #initialValue} method,
 * unless its value is {@linkplain #set set} by the current thread
 * in the interim.  This may result in multiple invocations of the
 * {@code initialValue} method in the current thread.
 *
 * @since 1.5
 */
 public void remove() {
     ThreadLocalMap m = getMap(Thread.currentThread());
     if (m != null)
         m.remove(this);
 }

/**
 * Get the map associated with a ThreadLocal. Overridden in
 * InheritableThreadLocal.
 *
 * @param  t the current thread
 * @return the map
 */
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

InheritableThreadLocal

同一个ThreadLocal变量在父线程中被设置值后,在子线程中是获取不到的。为了解决这个问题， InheritableThreadLocal应运而生。 InheritableThreadLocal继承自ThreadLocal，其提供了一个特性，就是让子线程可以访问在父线程中设置的本地变量。

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    /**
     * Computes the child's initial value for this inheritable thread-local
     * variable as a function of the parent's value at the time the child
     * thread is created.  This method is called from within the parent
     * thread before the child is started.
     * <p>
     * This method merely returns its input argument, and should be overridden
     * if a different behavior is desired.
     *
     * @param parentValue the parent thread's value
     * @return the child thread's initial value
     */
    protected T childValue(T parentValue) {
        return parentValue;
    }

    /**
     * Get the map associated with a ThreadLocal.
     *
     * @param t the current thread
     */
    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }

    /**
     * Create the map associated with a ThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the table.
     */
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

由如上代码可知， InheritableThreadLocal继承ThreadLocal，并重写了三个方法。由createMap方法可知， InheritableThreadLocal重写了createMap方法，那么现在当第一次调用set方法时，创建的是当前线程的inheritableThreadLocals变量的实例而不再是threadLocals。由getMap方法可知，当调用get方法获取当前线程内部的map时，获取的是inheritableThreadLocals而不再是threadLocals。
综上可知，在InheritableThreadLocal的世界里变量inheritableThreadLocals替代了threadLocals。

那么childValue方法何时执行呢？如何让子现场访问父线程本地变量？

 public Thread(Runnable target) {
     init(null, target, "Thread-" + nextThreadNum(), 0);
 }
 
 private void init(ThreadGroup g, Runnable target, String name,
                   long stackSize) {
     init(g, target, name, stackSize, null, true);
 }
 
 private void init(ThreadGroup g, Runnable target, String name,
                   long stackSize, AccessControlContext acc,
                   boolean inheritThreadLocals) {
     ......
//获取当前线程
     Thread parent = currentThread();
     ......
     //如果父线程的inheritableThreadLocals不为空
     if (inheritThreadLocals && parent.inheritableThreadLocals != null)
     //根据父线程的inheritableThreadLocals生成自己的
         this.inheritableThreadLocals = ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
     /* Stash the specified stack size in case the VM cares */
     this.stackSize = stackSize;

     /* Set thread ID */
     tid = nextThreadID();
 }
 
 
 
 static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
     return new ThreadLocalMap(parentMap);
 }
 
 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++;
                 }
             }
         }
 }

InheritableThreadLocal 通过重写getMap和createMap方法。 让本地变量保存到了具体线程的inheritableThreadLocal变量里面，那么线程在通过InheritableThreadLocal实例的set或者get方法设置变量时，就会创建当前线程的inheritableThreadLocals变量。当父线程创建子线程时，构造函数会把父线程中inheritableThreadLocals变量里面的本地变量复制一份保存到子线程的inheritableThreadLocals变量里面。