总述

    最近做了一个日志调用链路跟踪的项目，涉及到操作标识在线程和子线程，线程池以及远程调用之间的传递问题。最终采用了阿里开源的TransmittableThreadLocal插件(https://github.com/alibaba/transmittable-thread-local)完美解决。在分析源码以及中途修复bug的过程中，被ThreadLocal搞得晕头转向。好在静下心来细细啃了一下午,终于能理解各种ThreadLocal相关问题了。这里准备用博客记录下来。

关于弱引用

    要想了解ThreadLocal的底层原理首先就要了解弱引用。本篇不会详细介绍是强引用，啥是弱引用、软引用以及虚幻引用，有兴趣的同学可以自己百度。这里直接给出弱引用的简单代码说明：

Object obj = new Object();
WeakReference<Object> wf = new WeakReference<Object>(obj);	// 对堆内存中对象建立一个弱引用
obj = null;					// 去掉堆中对象的强引用
System.gc();									
System.out.println(wf.get());		// 输出null

可以看到弱引用的作用就在于当堆内存中对象不存在强引用的时候，在下一次gc的时候可能会回收掉堆内存占用。

走进ThreadLocal

    了解了弱引用之后，其实就能够很好地理解ThreadLocal(题外话：其实这个ThreadLocal我摸索了好久才弄得比较透彻)。直接上代码：

    首先我们需要注意Thread类中的两个属性：

public class Thread implements Runnable {
	// ....
	
	/* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
	// ThreadLocal实际值的存储所在
    ThreadLocal.ThreadLocalMap threadLocals = null;

    /*
     * InheritableThreadLocal values pertaining to this thread. This map is
     * maintained by the InheritableThreadLocal class.
     */
	// 后面要将的InheritableThreadLocal的实际值存储所在
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
}

这两个属性特别关键：

• 他是每个线程所特有的
• 两个属性的类型是ThreadLocal的内部静态类

他们是ThreadLocal的神奇魔法之关键~

    接下来我们来看看ThreadLocal的关键方法：

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

/**
 * Create the map associated with a ThreadLocal. Overridden in
 * InheritableThreadLocal.
 *
 * @param t the current thread
 * @param firstValue value for the initial entry of the map
 */
void createMap(Thread t, T firstValue) {
	// set时候的关键，实际上是创建一个当前ThreadLocal的弱引用为key的Map
	t.threadLocals = new ThreadLocalMap(this, firstValue);
}


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

/**
 * Get the map associated with a ThreadLocal. Overridden in
 * InheritableThreadLocal.
 * 最为关键的方法： 可以看出getMap实际上就是得到传入线程的threadLocals属性的值
 * @param  t the current thread
 * @return the map
 */
ThreadLocalMap getMap(Thread t) {
	return t.threadLocals;
}

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

不难看出，所有方法都是围绕着一个ThreadLocalMap来操作的，那么这个ThreadLocalMap究竟是啥，我们进一步来分析：

/**
 * ThreadLocalMap is a customized hash map suitable only for
 * maintaining thread local values. No operations are exported
 * outside of the ThreadLocal class. The class is package private to
 * allow declaration of fields in class Thread.  To help deal with
 * very large and long-lived usages, the hash table entries use
 * WeakReferences for keys. However, since reference queues are not
 * used, stale entries are guaranteed to be removed only when
 * the table starts running out of space.
 */
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.
	 */
	// 实际上他的存储也是利用Entry结构来进行的，只不过这个Entry的key值是弱音用对象，实际上可以将ThreadLocalMap看做WeakHashMap
	static class Entry extends WeakReference<ThreadLocal<?>> {
		/** The value associated with this ThreadLocal. */
		Object value;

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

至此，我们已经知道了ThreadLocal是如何实现的了，具体来说是下面几个关键点：

• ThreadLocal本身并不存储值，而是作为ThreadLocalMap的key用来查找对象所存储的值的
• 用来存储值的ThreadLocalMap是每个线程都有的非静态属性，当前线程实例该属性的值对其他线程实例是不可见的，这也就实现了线程隔离
• ThreadLocal的get方法实际上是先获取当前线程的ThreadLocalMap属性值，然后再通过ThreadLocal作为key获取实际上存储在Map中的值
• 因为ThreadLocalMap的Key是软引用的，所以如果ThreadLocal不存在强引用且线程被回收的话，存储在已回收线程ThreadLocalMap中的值也是会被回收的。这一点是通过两方面来实现的:1. Key是软引用，当没有强引用指向ThreadLocal时，ThreadLocalMap的以该ThreadLocal作为key的Entry中key会在gc时被回收置为null 2. 调用ThreadLocal的set/get/remove方法的时候会触发Entry的expungeStaleEntry方法，方法会将key为null的value值回收