ThreadLocal
- 什么是ThreadLocal
- 存取实质
- 使用场景
- 使用方法
- set()流程
- get()流程
- 内存泄漏问题
1. 定义
是一个泛型类public class ThreadLocal<T>，线程内部的数据存储类。能够在指定线程中存储数据。存储的数据也只能在存的线程中获取到。
2. 存取实质
ThreadLocal存取数据实际是向当前操作线程的一个数组（ThreadLocalMap中的table）中存取值。
public class Thread implements Runnable {
// ......
// 每个线程对象都会持有一个ThreadLocalMap，存储数据的容器
ThreadLocal.ThreadLocalMap threadLocals = null;
// ......
}
ThreadLocalMap虽然叫map，但其实并不是一个map，它封装了一个数组，通过ThreadLocal对象的哈希去索引数组下标从而进行数据的存取操作。
static class ThreadLocalMap {
// ......
// map中的数据数组
private Entry[] table;
// ......
}
Entry是ThreadLocalMap的内部类，继承了WeakReference<ThreadLocal<?>>，是一个弱引用Threadocal对象的弱引用类。内部有一个Object，也就是我们索要存储的数据了。既然是弱引用，那么ThreadLocal对象就有可能会被回收，就有可能在Entry数组中出现某个Entry对象指向为空的情况，此时该Entry已经没有用处了，因为无法再次通过ThreadLocal去访问到，便要将其从Entry数组中清除。
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、Entry、Thread。如上图ThreadLocal可以获取当前执行的Thread对象，Thread对象可以获取到其成员ThreadLocalMap，通过ThreadLocal对象计算Entry在数组中的位置，然后获取Entry的value成员，也就是我们存储的数据了。取的过程与之相反。
ThreadLocalMap是ThreadLocal的内部类，每一个Thread对象都有一个只属于自己的ThreadLocalMap对象。ThreadLocal封装了对当前操作线程的ThreadLocalMap存取操作，ThreadLocalMap封装了对自身维护的Entry数组的存取操作。
3. 场景
- 当某些数据是以线程为作用域，且不同线程具有不同的数据副本时，ThreadLocal就能派上用场。
- 比如Looper的作用域就是线程，并且不同的线程有不同的Looper。
- 如果不使用ThreadLocal，就需要提供一个全局Hash表供Handler查找指定线程的Looper，ThreadLocal就方便很多了。
- 当一个线程中的任务复杂，又需要一个对象贯穿执行过程，可将其存储在ThreadLocal中。
- 如果不使用ThreadLocal，一种方法是传参，这种方法让程序设计看起来糟糕。
- 另一种就是作为静态变量供线程访问（可扩展性差，如果多个线程都需要自己的对象，不可能有几个线程就设置几个静态变量）。
4. 使用方法
- 创建一个ThreadLocal对象，泛型为存的数据的类型。
private ThreadLocal<Integer> mLocal = new ThreadLocal<>();
- 给创建的ThreadLocal对象赋值
在不同的线程中设置不同的值并访问输出。
// 在主线程设置0后输出。
mLocal.set(0);
Log.d(TAG, "MainT: " + mLocal.get());
new Thread(() -> {
// 在第一条子线程设置1后输出。
mLocal.set(1);
Log.d(TAG, "T1: " + mLocal.get());
}).start();
new Thread(() -> {
// 在第二条子线程不设置值，直接输出。
Log.d(TAG, "T2: " + mLocal.get());
}).start();
输出如下，虽然访问的都是同一个对象，但是在不同线程中调用get()却是在不同线程中设置的不同值，没有设置则为null。因为set到的是不同线程对象中的数组，get也是从不同线程中的数组去获取值。
D/HandlerTestActivity: MainT: 0
D/HandlerTestActivity: T1: 1
D/HandlerTestActivity: T2: null
5. ThreadLocal的set()
在创建好ThreadLocal对象后，需要调用其set()设置对象的值。
ThreadLocal # set()
- 获取当前操作线程的实例。
- 获取当前线程的map。
- 是否该线程是否已经有map。
- 是：直接将数据加入map。
- 否：创建map并加入数据。
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
ThreadLocal # getMap()
返回Thread类的全局变量threadLocals。
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
Thread类的这个threadLocals初始赋值为null，类型就是ThreadLocal的内部类ThreadLocalMap。
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal # createMap()
直接调用构造方法实例化。
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
ThreadLocalMap # ThreadLocalMap()
- 创建了一个Entry数组，初始大小默认为16，这也就是前面说到的线程中的数组了。Entry是ThreadLocalMap的内部类。
- 利用该ThreadLocal对象的hash值获得一个索引值。
- 创建一个Entry对象并加入Entry数组，最后对数组进行扩充。
private static final int INITIAL_CAPACITY = 16;
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
ThreadLocalMap # set()
会先遍历Entry数组，如果有对象，就判断key是否和需要加入的一样，如果一样就替换value，如果key不一样就继续找下一个位置，等找到空位，就添加进去。
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
// 使用了ThreadLocal对象的threadLocalHashCode，是唯一确定的。
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();
}
6. ThreadLocal的get()
- 如果map存在
- 就直接拿值，如果值不为空，就直接返回。
- 如果map不存在或者值为空，就调用setInitialValue()。
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();
}
ThreadLocal # setInitialValue()
- 如果map为空，就创建map并添加默认值。
- 如果不空，就直接添加默认值。
- 最后返回默认值。
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;
}
默认值为null，也可以根据自己的需求重写这个方法。
protected T initialValue() {
return null;
}
7. 内存泄漏问题
比如说申明了一个ThreadLocal对象，并放入了数据。
ThreadLocal<Button> local = new ThreadLocal<>();
local.set(new Button(this));
经过一系列的使用之后此时我们不在需要此Button了，出了代码块，此时就相当于是执行了：
local = null;
对ThreadLocal对象的强引用没有了，只有一个Entry对其的弱引用，在下一次GC时便会回收掉该ThreadLocal对象。但是问题出在Entry对象被ThreadLocalMap中的数组强引用着无法回收，它的value一直存在，哪怕key此时已经为null不再会使用该value了，就造成了内存泄漏。ThreadLocalMap中可能会存在很多key为null的Entry。
对应这种情况，ThreadLocal在set()、get()等中，遍历查询位置时都可能会调用到ThreadLocalMap的expungeStaleEntry()，该方法就是去清除向后寻找路途中所有key为null的Entry对象的。
// 该方法在ThreadLocal调用get()，调用到ThreadLocal的getEntry()第一次匹配不成功时会被调用到。
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;
}
但是这样仍然不是很保险，因为如果不再调用这些操作，就无法清除无用对象了，除非线程结束。所以保险起见还是应该去手动调用ThreadLocal的remove()清除该无用Entry。
