Android源码学习(4) Handler之ThreadLocal

线程的threadLocals

Looper通过sThreadLocal来设置线程与Looper的对应关系，sThreadLocal是范型类ThreadLocal<Looper>的实例，其添加、移除元素的操作如下：

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

从代码中可以看出，Looper对象实际上是被添加到当前线程的本地数据表中(t.threadLocals是ThreadLocalMap的实例)。ThreadLocalMap是通过hash表实现的，sThreadLocal被用作key。因此，查询任何线程的Looper时，都是以同一个变量(sThreadLocal)为key进行的。

ThreadLocalMap

ThreadLocalMap底层其实是数组实现的hash表，其类定义如下：

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;
        }
    }

    /**
     * The initial capacity -- MUST be a power of two.
     */
    private static final int INITIAL_CAPACITY = 16;

    /**
     * The table, resized as necessary.
     * table.length MUST always be a power of two.
     */
    private Entry[] table;

    /**
     * The number of entries in the table.
     */
    private int size = 0;

    /**
     * The next size value at which to resize.
     */
    private int threshold; // Default to 0
    
}

Entry是静态内部类，定义了hash表的元素类型。该类继承WeakReference，实质上持了ThreadLocal的弱引用，value为实际的线程本地变量，在本例中为Looper对象。

插入节点

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();
}

private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0);
}

第10行，可以看到hash函数是取threadLocalHashCode的低位，作为索引访问Entry数组。当存在冲突时(即当前位置已经被占了)，则从当前位置开始查找下一个可用的位置。

由于Entry是弱引用，所以其引用的ThreadLocal可能会被GC回收，因此在插入元素时，从hash函数计算的索引i开始查找：1) 若tab[i]为空，表明位置可用，则直接放入该位置；2) 若tab[i]的key与插入的key匹配，则更新该位置处的value；3) 若tab[i]的key为空，说明key已失效(被GC回收)，则调用replaceStaleEntry将元素放入该位置。

replaceStaleEntry具体流程如下：从staleSlot的下一位置开始查找待插入的key是否已经存在表中，若是，则更新其value值并将其与staleSlot位置处的元素交换；否则，直接将其放置在staleSlot处。replaceStaleEntry的代码如下：

private void replaceStaleEntry(ThreadLocal key, Object value,
                               int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    // Back up to check for prior stale entry in current run.
    // We clean out whole runs at a time to avoid continual
    // incremental rehashing due to garbage collector freeing
    // up refs in bunches (i.e., whenever the collector runs).
    int slotToExpunge = staleSlot;
    for (int i = prevIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;

    // Find either the key or trailing null slot of run, whichever
    // occurs first
    for (int i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal k = e.get();

        // If we find key, then we need to swap it
        // with the stale entry to maintain hash table order.
        // The newly stale slot, or any other stale slot
        // encountered above it, can then be sent to expungeStaleEntry
        // to remove or rehash all of the other entries in run.
        if (k == key) {
            e.value = value;

            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;

            // Start expunge at preceding stale entry if it exists
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        // If we didn't find stale entry on backward scan, the
        // first stale entry seen while scanning for key is the
        // first still present in the run.
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // If key not found, put new entry in stale slot
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);

    // If there are any other stale entries in run, expunge them
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

由于某些ThreadLocal可能已经被GC回收，所以replaceStaleEntry会调用expungeStaleEntry和cleanSomeSlots清理已经被GC回收的元素，并将其value置空，防止内存泄漏。

expungeStaleEntry从指定位置staleSlot处开始清理失效元素，expungeStaleEntry的具体流程如下：先清理staleSlot位置处的元素，然后从staleSlot的下一位置开始查找，若遇到失效元素，则将其清理；若遇到合法元素，则对其进行rehash，调整其位置；若遇到空值，则循环退出。expungeStaleEntry的代码如下：

private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;

    // expunge entry at staleSlot
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;

    // Rehash until we encounter null
    Entry e;
    int i;
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal k = e.get();
        if (k == null) {
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            int h = k.threadLocalHashCode & (len - 1);
            if (h != i) {
                tab[i] = null;

                // Unlike Knuth 6.4 Algorithm R, we must scan until
                // null because multiple entries could have been stale.
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}

当清理掉一个元素，需要对其后面元素进行rehash的原因跟解决冲突的方式有关，设想hash表中存在冲突：

...,<key1(hash1), value1>, <key2(hash1), value2>,...（即key1和key2的hash值相同）

此时，若插入<key3(hash2), value3>，其hash计算的目标位置被<key2(hash1), value2>占了，于是往后寻找可用位置，hash表可能变为：

..., <key1(hash1), value1>, <key2(hash1), value2>, <key3(hash2), value3>, ...

此时，若<key2(hash1), value2>被清理，显然<key3(hash2), value3>应该往前移(即通过rehash调整位置)，否则若以key3查找hash表，将会找不到key3

cleanSomeSlots从指定位置i开始，以log2(n)为窗口宽度，检查并清理失效元素。cleanSomeSlots的实现代码如下：

private boolean cleanSomeSlots(int i, int n) {
    boolean removed = false;
    Entry[] tab = table;
    int len = tab.length;
    do {
        i = nextIndex(i, len);
        Entry e = tab[i];
        if (e != null && e.get() == null) {
            n = len;
            removed = true;
            i = expungeStaleEntry(i);
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}

第9行，如果检查到失效元素，则n会被重新赋值为len，所以该函数有可能把整个hash表的失效元素都清理掉。

删除节点

删除节点比较简单，代码如下：

private void remove(ThreadLocal key) {
    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)]) {
        if (e.get() == key) {
            e.clear();
            expungeStaleEntry(i);
            return;
        }
    }
}

rehash

最后，我们来看下resh操作。具体流程如下：首先，清理掉所有的失效节点；若清理之后，表的大小还是超过了扩容的阈值，则进行resize操作将hash表的数组尺寸扩大一倍。rehash代码如下：

private void rehash() {
    expungeStaleEntries();

    // Use lower threshold for doubling to avoid hysteresis
    if (size >= threshold - threshold / 4)
        resize();
}

private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;
    Entry[] newTab = new Entry[newLen];
    int count = 0;

    for (int j = 0; j < oldLen; ++j) {
        Entry e = oldTab[j];
        if (e != null) {
            ThreadLocal k = e.get();
            if (k == null) {
                e.value = null; // Help the GC
            } else {
                int h = k.threadLocalHashCode & (newLen - 1);
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                count++;
            }
        }
    }

    setThreshold(newLen);
    size = count;
    table = newTab;
}

private void expungeStaleEntries() {
    Entry[] tab = table;
    int len = tab.length;
    for (int j = 0; j < len; j++) {
        Entry e = tab[j];
        if (e != null && e.get() == null)
            expungeStaleEntry(j);
    }
}

总结

ThreadLocalMap持了ThreadLocal的弱引用，而value值是强引用，显然这可能导致value临时泄漏。比如我们以线程池(ExecutorService)中线程构建Looper，当调用Looper的quit或者quitSafely退出Looper循环，此时因为线程来自于线程池，因此线程仍然会存活，加上Looper.sThreadLocal是静态变量，加入线程的threadLocals中的Looper显然是无法被清理，因而无法被GC回收。