了解ThreadLocal

2018-10-19 本文已影响22人 Utte

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。