Android 分析ThreadLocal类

在学习Android应用开发，使用Handle处理消息机制时，想了解整个调用的流程，现在来暂时看看其中一环ThreadLocal类。在Android 8.0 的环境下开发。

官方介绍：

官方对ThreadLocal类的解析为：

/**
 * Implements a thread-local storage, that is, a variable for which each thread
 * has its own value. All threads share the same {@code ThreadLocal} object,
 * but each sees a different value when accessing it, and changes made by one
 * thread do not affect the other threads. The implementation supports
 * {@code null} values.
 *
 * @see java.lang.Thread
 * @author Bob Lee
 */

一种线程存储的实现。所有线程共享同一个ThreadLocal类，改变某一个线程当中的值不影响其他线程。

具体是什么意思，写简单测试代码来理解一下：

final ThreadLocal<Integer> mIntThreadLocal = new ThreadLocal<Integer>();

new Thread() {
	@Override
	public void run() {
	mIntThreadLocal.set(1);
	System.out.println("Thread 1  : " + mIntThreadLocal.get());
	};
}.start();

new Thread() {
	@Override
	public void run() {
	mIntThreadLocal.set(2);
	System.out.println("Thread 2  : " + mIntThreadLocal.get());
	};
}.start();

输出为：

System.out: Thread 1  : 1

System.out: Thread 2  : 2

功能明显，分别在线程1、2中存储了变量1、2，并正确读取出来。

 

源码分析：

ThreadLocal一个类，使用了泛型。

public class ThreadLocal<T> {
    ...
}

 

 set方法：

获取Thread类里面的成员变量，类型为ThreadLocalMap（此变量在线程初始化时创建）

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

map.set()函数原型为下图，table数组在构造ThreadLocalMap类时已经初始化，为长度16的数组。寻址

i = key.threadLocalHashCode & (len-1);

是根据哈希桶算法原理对数组长度-1进行与操作，使得能够均匀分布到tab数组里。

通过 tab[i] = new Entry(key, value);

往后添加新成员。Entry其中为存储value值的一个类，通过key值来匹配value。

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

就这样，调用mIntThreadLocal.set(1);函数等于操作了该线程类里的类型为ThreadLocalMap的成员变量threadlocals。原型参考下图。

public
class Thread implements Runnable {
    ...
    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;
    ...
}

 

get方法：

与set方法一样，获取Thread类里面的成员变量，类型为ThreadLocalMap的成员变量threadlocals

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

重点在map.getEntry()函数，原型为

private Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }

显然，通过hash寻址数组返回了table[i]里面的值。

 

总结：

通过创建了一个ThreadLocal对象来存储不同线程的变量。对应关系如下图：

这个有什么用呢？

1.每个线程里都有自己的threadlocals变量，保证可以访问自己的变量不干预。

2.只需要一个实例ThreadLocalMap就可以访问不同线程的资源。

在研究Android的Handle消息响应时还会涉及到，有兴趣的可以看下一篇文章。