一. ThreadLocal 是什么
ThreadLocal用于实现在不同的线程中存储线程私有数据的类，通过它可以在指定的线程中存储数据，数据存储以后，只有在指定线程中可以获取到存储的数据，对于其他线程来说则无法获取到数据。
二. ThreadLocal 源码解析
1.set方法
/**
* 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);
}
整个流程如下：
- 获取当前线程
- 使用当前线程获取一个 ThreadLocalMap 对象
- 如果获取到的 map 对象不为空，则设置值，否则创建 map 设置值
getMap 源码：
/**
* 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;
}
getMap()方法 获取到的是Thread对象的threadLocals 变量，类型为 ThreadLocal.ThreadLocalMap。
如果 map 对象为空，则新建 ThreadLocalMap 对象。
/**
* 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) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
由此可知：每个线程都有一个保存值的ThreadLocalMap 对象，ThreadLocal的值就存放在了当前线程的 ThreadLocalMap成员变量中，所以只能在本线程访问，其他线程不能访问。
ThrealLocal的值是如何在threadLocals中进行存储的呢? 在 threadLocals 内部有一个数组，private Entry[] table，ThrealLocal 的值就存在这个 table 数组中。
/**
* 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.
*/
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
在看看ThreadLocalMap的保存方法：ThreadLocalMap#set
/**
* Set the value associated with key.
*
* @param key the thread local object
* @param value the value to be set
*/
private void set(ThreadLocal<?> key, Object value) {
// We don't use a fast path as with get() because it is at
// least as common to use set() to create new entries as
// it is to replace existing ones, in which case, a fast
// path would fail more often than not.
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
if (k == 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();
}
set()方法实现了数据的存储，其中 table 是一个 Entry[] 数组对象，而 Entry 是用来存储 ThreadLocal key, Object value 的，逻辑是根据 key 找出 Entry 对象，如果找出的这个 Entry 的 k 等于 key，直接设置 Entry 的 value，如果 k 为空，则通过 replaceStaleEntry 保存数据，最后构建出Entry保存进table数组中。
2.get方法
/**
* 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 方法首先取出当前线程的 ThreadLocalMap 对象，如果这个对象为空，则返回默认值；如果不为空，使用当前 ThreadLoacl 对象(this)获取 ThreadLocalMap 的 Entry 对象，返回 Entry 保存的 value 值。
ThreadLocal使用场景：
Android系统的Looper类,开源框架EventBus 都有运用到ThreadLocal进行线程局部数据的存储。
// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
防止内存泄漏
对于已经不再被使用且已被回收的 ThreadLocal 对象，它在每个线程内对应的实例由于被线程的 ThreadLocalMap 的 Entry 强引用，无法被回收，可能会造成内存泄漏。
针对该问题，ThreadLocalMap 的 set 方法中，通过 replaceStaleEntry 方法将所有键为 null 的 Entry 的值设置为 null，从而使得该值可被回收。另外，会在 rehash 方法中通过 expungeStaleEntry 方法将键和值为 null 的 Entry 设置为 null 从而使得该 Entry 可被回收。通过这种方式，ThreadLocal 可防止内存泄漏，可参考上述set方法源码！
总结
ThreadLocal 是线程内部的数据存储类，每个线程中都会保存一个 ThreadLocal.ThreadLocalMap threadLocals
ThreadLocalMap 是 ThreadLocal 的静态内部类，里面保存了一个 private Entry[] table 数组，这个数组就是用来保存 ThreadLocal 中的值。
从 ThreadLoacl 的 set 和 get 方法来看，它们操作的对象都是当前线程对象中的 ThreadLocalMap 对象的 Entry[] 数组，因此在不同的线程中访问同一个 ThreadLoacl 的 set 和 get 方法，操作的对应线程中的数据，所以不会影响到其他线程。
ThreadLocalMap 的 Entry 对 ThreadLocal 的引用为弱引用，避免了 ThreadLocal 对象无法被回收的问题
ThreadLocalMap 的 set 方法通过调用 replaceStaleEntry 方法回收键为 null 的 Entry 对象的值（即为具体实例）以及 Entry 对象本身从而防止内存泄漏
