深入理解ThreadLocal（一）

Android里，在不同的线程(假设子线程已经创建了Looper)中创建Handler时，并不需要显式指定Looper，系统能自动找到该线程自己的Looper。不同线程的Looper相互独立，之所以能做到这一点，就是借助ThreadLocal来实现的。下面结合源码来分析ThreadLocal的使用及实现原理。

1 ThreadLocal的使用

先来看一个ThreadLocal使用的例子：

[java] view plain copy 

public class ThreadLocalTest {
    static ThreadLocal mThreadLocal = new ThreadLocal<Long>();
    static long id=0;

    public ThreadLocalTest() {
        id = Thread.currentThread().getId();
        mThreadLocal.set(id);
    }

    public void printValue() {

        System.out.println("Thread " + Thread.currentThread().getId() + ":	 value=" + mThreadLocal.get() + "	 id=" + id);
    }

    static class PrintValueRunnable implements Runnable {

        @Override
        public void run() {
            // TODO Auto-generated method stub
            ThreadLocalTest test = new ThreadLocalTest();

            test.printValue();

        }
    }

    public static void main(String[] args) {
        new Thread(new PrintValueRunnable()).start();

        new Thread(new PrintValueRunnable()).start();
    }
}

上面代码展示了ThreadLocal的基本用法。定义了2个类变量mThreadLocal和id，一个成员方法printValue用来打印mThreadLocal和id的值，定义一个PrintValueRunnable在run方法中会先new一个ThreadLocalTest的实例，然后调用printValue来打印值。最后在main函数里面，创建两个线程，在线程里面执行PrintValueRunnable来执行打印任务。在ThreadLocalTest因为mThreadLocal和id都是类成员变量，所以在两个线程中都可以访问。在ThreadLocalTest的构造函数中会分别将线程id保存到mThreadLocal和id中。下面先看一下打印结果：

 

 从打印结果可以看到：mThreadLocal中保存时每个线程的ID，但是id保存的是同一个ID值。因为id是两个进程内共享的，所以id的值是后一个执行的线程的id。mThreaLocal也是进程内共享的，但是mThreadLocal.get()能保证不同线程间调用mThreadLocal.set()进来的值互不干扰。所以，当每个线程是用ThreadLocal来保存Looper的时候，可以保证在任何时候任何地方创建的Handler都能正确的拿到当前线程的Looper。

那ThreadLocal是怎么做到这一点的呢?

 2 ThreadLocal的实现原理分析

 其实在Thread中有一个hash结构的ThreadLocal.ThreadLocalMap对象的实例threadLocals，threadLocals中才是真正保存变量的地方。ThreadLocal负责管理threadLocals中保存的变量。

下面结合ThreadLocal的源码来分析它的实现原理。先来看ThreadLocal的set和get方法：

[java] view plain copy

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

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

 void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T)e.value;
        }
        return setInitialValue();
    }

可以看到，在set中以当前线程的实例为参数调用getMap获取当前线程的ThreadLocalMap对象，如果线程的threadLocals不为null，就将value保存到threadLocals中，反之，先创建一个ThreadLocalMap实例。ThreadLocal.get()也是从threadLocals中来读取value。从这儿也可以看出，我们想要隔离的value并不是保存到ThreadLocal中，而是在每个线程对象的内部来保存。因为是每个线程自己来保存value，所以做到了线程间相互隔离。

第5行代码需要我们注意，在set中保存value的时候，是以this即当前ThreadLocal实例为键，以待保存的变量value为值来保存的。

下面看下ThreadLocalMap的具体实现，先看构造函数：

[java] view plain copy 

/**
         * Construct a new map initially containing (firstKey, firstValue).
         * ThreadLocalMaps are constructed lazily, so we only create
         * one when we have at least one entry to put in it.
         */
        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);
        }

在构造函数中，先new一个Entry数组，默认大小INITIAL_CAPACITY为16。随着元素增多，会动态调整其大小，但都是2n。然后根据ThreadLocal.threadLocalHashCode来计算hash值，具体算法如第8行所示。再看一下Entry的定义：

[java] view plain copy 

static class Entry extends WeakReference<ThreadLocal> {
           /** The value associated with this ThreadLocal. */
           Object value;

           Entry(ThreadLocal k, Object v) {
               super(k);
               value = v;
           }
       }

可以看到Entry继承与WeakReference，ThreadLocalMap中的键ThreadLocal对象通过软引用来保存，值则保存到一个Object的实例value中。

再来看一下调用set/get时，ThreadLocalMap是怎样查找对象的，通过前面的代码知道调用ThreadLoca.set的时候是通过调用ThreadLocalMap.set来完成的，先看set：

[java] view plain copy 

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

在set中，先在第10行计算hash值，并作为在table中查找的起点。在查找的过程中，如果当前Entry的key与待插入的key相同，则直接更新value。如果找到一个空的Entry，则退出循环，然后插入value。通过nextIndex可以看到，如果插入的时候发生碰撞，那么采用线性探查来计算下一个位置。在查找的过程中，如果遇到key为null的Entry(因为key是一个软引用，所以每次gc之后就可能有key为null)，如第22行所示，会调用replaceStaleEntry继续查找，如果没有更合适的，则插入到当前位置。插入完成如果有必要，会对hash表进行清理：删除掉key为null的Entry，并对受影响的部分进行重新hash。

再看一下ThradLocalMap的get操作：

[java] view plain copy 

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

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

getEntry很简单，先计算hash值，然后比较entry中保存的key是否与待查找的key一致，如果是则直接返回，反之，按照线性探查法继续查找。查找的过程中，如果发现有Entry的key为null，则会调用expungeStaleEntry进行清理，并对受影响的部分重新hash。

到此为止，已经分析完ThradLocal的实现原理：

在Thread中有一个hash结构的ThreadLocal.ThreadLocalMap对象的成员变量threadLocals，threadLocals中以ThreadLocal对象为key，以要隔离的值为value(即调用threadLocal.set(value)中的value)。ThreadLocal负责管理threadLocals中保存的变量。