概述
ThreadLocal是一种线程内部存储类。通过他存储的数据在不同的线程操作而互不干扰，类似于各个线程中都有一份自己的copy数据做处理。正如源码中的注解解释:
This class provides thread-local variables.
Android消息机制中就用到了该类来存储每个线程的Looper。
概念可能有些抽象，下面举一个简单的例子：
private final String TAG = "MainActivity";
private ThreadLocal<String> threadLocal = new ThreadLocal<>();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
threadLocal.set("mainThread");
Log.d(TAG, "this is mainThread ,threadLocal = " + threadLocal.get());
new Thread("Thread_1") {
@Override
public void run() {
super.run();
Log.d(TAG, "this is Thread_1 ,before calling set method , threadLocal = " + threadLocal.get());
threadLocal.set("Thread_1");
Log.d(TAG, "this is Thread_1 ,after calling set method , threadLocal = " + threadLocal.get());
}
}.start();
new Thread("Thread_2") {
@Override
public void run() {
super.run();
Log.d(TAG, "this is Thread_2 ,before calling set method , threadLocal = " + threadLocal.get());
threadLocal.set("Thread_2");
Log.d(TAG, "this is Thread_2 ,after calling set method , threadLocal = " + threadLocal.get());
}
}.start();
}
上述实例代码中在MainThread中给ThreadLocal赋值了“mainThread”，并打印结果。然后在“Thread_1”和“Thread_2”中打印输出ThreadLoal的值，再重新赋值打印。输出结果如下：
this is mainThread ,threadLocal = mainThread this is Thread_2 ,before calling set method , threadLocal = null this is Thread_2 ,after calling set method , threadLocal = Thread_2 this is Thread_1 ,before calling set method , threadLocal = null this is Thread_1 ,after calling set method , threadLocal = Thread_1
从上述日志可以看到，3个不同的线程虽然都在访问同一个ThreadLoal，但是获取的值是不同的。相当于每个线程都有属于自己的一个ThreadLoal副本，各自线程中互不干扰。
ThreadLoal源码分析
ThreadLoal的构造方法是个空方法，直接来看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();
//根据当前线程获取ThreadLoacalMap
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
/**
* 新建ThreadLocalMap
*/
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
//Thread.java
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
注解中指出，该方法是把值赋值给当前线程的局部变量副本。此处代码逻辑比较清晰，如果ThreadLoacalMap不为空则将set操作转移给了ThreadLocalMap，否则创建一个ThreadLoacalMap。ThreadLocalMap是ThreadLoacal的静态内部类，在每个Thread类中都已经定义了初始值为null的ThreadLoacalMap。先来分析下ThreadLocalMap的构造方法：
//初始容量
private static final int INITIAL_CAPACITY = 16;
ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
//根据key的hash进行数组坐标的相关计算
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
//设置阈值
setThreshold(INITIAL_CAPACITY);
}
static class Entry extends WeakReference<ThreadLocal> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal k, Object v) {
super(k);
value = v;
}
}
从上面代码可以看出，ThreadLoacalMap定义了一个名为table的Entry[]数组，创建一个Entry对象，根据key的相关hash运算得到数组下标，存储在table中。ThreadLocalMap的set方法便是在构造方法的基础上对重复元素进行一些处理：
private void set(ThreadLocal key, Object value) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
//从i开始向后遍历，查看table中是否已经存放过该key的数据或是table中有key为null的
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal k = e.get();
//更新value
if (k == key) {
e.value = value;
return;
}
//替换该位置上的Entry
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
//table中没有空位置且该数据为新增Entry
tab[i] = new Entry(key, value);
int sz = ++size;
//是否需要扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
从以上方法可以看出，操作的数据是以ThreadLoacal.ThreadLoacalMap.Entry对象的形式存储，而实际才存储位置是在table数组中。ThreadLoacalMap的set方法和ThreadLoacalMap的的构造方法一样，同样是根据key来计算存放在数组中的下标，便从该下标i开始向后遍历。如果存在该key则进行value的update。如果该下标位置是个空位置（因为Entry采用的是WeakReference弱引用，如果被回收了则不需要再存储改数据）则直接替换成我们新set的数据，而replaceStaleEntry方法里面则执行了一些回收替换操作。如果table中没有空位置且该数据为新增Entry，那么就插入一个新数据，为了防止数组越界，需要对存储容量做计算，判断是否需要扩容和重包装。threshold就是扩容或是重包装的临界点：
threshold= len * 2 / 3;
rehash()方法则进行table的重包装和重新设置大小的：
private void rehash() {
//删除一些旧的的Entry
expungeStaleEntries();
// Use lower threshold for doubling to avoid hysteresis
if (size >= threshold - threshold / 4)
resize();
}
上述代码中看到table做了一些删除工作，如果存储量达到了3/4就要去重新计算存储空间。resize方法对table的容量扩充了一倍并重新设定了threshold的值。上面分析了ThreadLocal的set方法，这里分析下它的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();
}
可以发现，ThreadLocal的get方法的逻辑比较清晰，它取出当前线程的ThreadLocalMap.Entry对象，如果这个对象为null那么就返回初始值，初始值由ThreadLocal的setInitialValue方法来描述，默认情况下为null，开发者可以根据需要去重写该方法。而这个获取的ThreadLocalMap.Entry就是set方法存储在table中的数据，直接根据key计算出来下标从table数组中去获取，ThreadLoacal还针对数据有可能丢失的情况做了处理：
private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
while (e != null) {
ThreadLocal k = e.get();
if (k == key)
return e;
if (k == null)
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
上述代码逻辑也比较清晰了，ThreadLoacal会对table向后遍历，查找是否有对应的数据，整改table中都没有才会返回null。
从ThreadLocal的set和get方法可以看出，它们所操作的对象都是当前所在线程的ThreadLoacalMap对象中的table数组，所以在不同线程中访问同一个ThreadLocal的set和get方法，它们对ThreadLocal所做的读写操作都是在各自线程的内部，这就能解释为什么ThreadLocal在多个线程中存储和修改数据都是互不干扰地的了。在Android的消息处理机制中，便用了ThreadLoacal来存储Looper。
从ThreadLoacal的角度来说，ThreadLoacal只是数据存储/获取事件的分发者，在哪个Thread中调用就将数据派发到哪个Thread中，实际存储/获取还是在各种Thread中。而从Thread的角度来说，ThreadLoacal只是存储的key，根据ThreadLoacal来存储和获取相应的value。
