简介
ThreadLocal 作用就像它的名字一样，通过 ThreadLocal 将传入的对象变成线程私有化的对象，即传入的对象只对传入它的线程可见。
在看 Android 的消息机制的时候，在 Looper 类的中的 prepare() 方法中看到了 ThreadLocal 的使用。
public static void prepare() {
prepare(true);
}
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));
}
这里的 sThreadLocal.set(new Looper(quitAllowed)) 便是使用了 ThreadLocal 的 set() 方法传入了一个 Looper 对象。
我们也从这里看一下 ThreadLoacl 实现的原理。
ThreadLoacl 的 set() 方法
public void set(T value) {
//获取当前线程
Thread t = Thread.currentThread();
//获取当前线程的 ThreadLocalMap
ThreadLocalMap map = getMap(t);
//如果 map 不为 null，那么将对象存入
if (map != null)
map.set(this, value);
//否则创建一个新的 ThreadLocalMap
else
createMap(t, value);
}
这一部分的源码还是很简单，首先获取当前线程，再去获取当前线程的 ThreadLocalMap，最后将我们传入的对象存放在 ThreadLocalMap 中。
这里去 getMap() 方法中看下 ThreadLocalMap 是个怎么样的数据结构。
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
可以看到这里返回了 Thread 中的 threadLocals 字段，说明了 ThreadLocal 只是一个帮助我们实现线程对象私有化的工具，具体私有化的对象还是存放在 Thread 自身的。
再看下 createMap() 方法
void createMap(Thread t, T firstValue) {
// 这里就是为 Thread 创建一个 ThreadLocalMap
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
这里我们对 set() 方法的流程有了一个清晰的认知，接下来去看一下 ThreadLocalMap。
ThreadLocalMap
这里看下 ThreadLocalMap 的结构。
ThreadLocalMap 中的弱引用
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.
*/
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
····
}
这里可以看见 ThreadLocalMap 中的 Entry 是继承弱引用的，所以当线程回收的时候，ThreadLocalMap 不会因为持有对象引用而导致线程无法回收。
构造方法
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
//INITIAL_CAPACITY 的值是 16
table = new Entry[INITIAL_CAPACITY];
//计算 hashcode 来确定其在数组中的位置
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
//设置阈值，超过就扩容，阈值为容积的 2/3
setThreshold(INITIAL_CAPACITY);
}
接下来直接去看下 set() 方法中用到过的 ThreadLocalMap 的 set() 方法，来对 ThreadLocalMap 做个基本的了解。
ThreadLocalMap 的 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.
//获取 table
Entry[] tab = table;
int len = tab.length;
//计算索引
int i = key.threadLocalHashCode & (len-1);
//这里是为了找到已经存在的 Entry，对其中已经存在的值进行替换, 其中 nextIndex() 方法就是对 i+1 取 len 的余
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;
}
}
//如果没有重复 key 的 Entry， 那么添加新的 Entry 到数组中
tab[i] = new Entry(key, value);
int sz = ++size;
//如果超出阈值，那么扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
这里就不介绍扩容了，对 ThredHashMap 做一个大致的了解即可，其实它的原理还是和 HashMap 非常像的。
ThreadLocal 的 get() 方法
看完上面的 set 的流程其实已经对 ThreadLocal 有一定的了解了，接下来我们看下他的 get() 方法。
public T get() {
//同样是获取当线程并且获取它的 ThreadLocalMap
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
//如果map不为空，尝试获取它的 Entry 对象
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
//如果 entry 不为空，返回私有化的对象
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//以上条件不符合，则返回初始值
return setInitialValue();
}
继续看 setInitialValue() 方法
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;
}
protected T initialValue() {
return null;
}
这里可以看到，它会通过 initialValue() 方法直接返回 null 值，同时再尝试去获取一下 map 是否存在，不存在的话就创建一个 map，反之将值存入map,最后会返回 null 值。
总结
ThredLocal 的介绍就到这里了，这里对它做个总结。
- 每个 Thread 都存有一个 ThreadLocalMap
- ThreadLocal 本身不缓存任何值，是对 Thread 中的 ThreadLocalMap 进行操作。
- ThreadLocalMap 与 HashMap 十分相似，但是是一个纯数组的实现的 Map, 它以线程做为键值，同时每个线程只能缓存一个对象。
- ThreadLocalMap 的初始容量 为 16， 阈值为容量的 2/3，超出阈值会触发扩容， 扩容为原来的两倍。
- ThreadLocalMap 遇到哈希碰撞时，是将索引向后移动一位处理。
- ThreadLocal set 和 get 都是以当前线程为键值获取 ThreadLocal Map 中的对象，以此实现线程对象的私有化。
最后回到前面我遇到 ThreadLocal 的地方
public static void prepare() {
prepare(true);
}
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));
}
这里就是将 Looper 对象传入 ThreadLocal，保证 Looper 只对当前线程可见，避免并发危险。
