Handler消息机制-ThreadLocal的使用

ThreadLocal是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据。数据存储以后，只有在指定的线程中才能获取到数据，其他线程则无法获取到数据。所以ThreadLocal用于存储一些以线程为作用域、不同线程具有不同的数据副本的数据。一个典型的使用场景：

ThreadLocal<Boolean> mThreadLocal = new ThreadLocal<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        mThreadLocal.set(true);
        Log.i("ruxing", "ThreadLocal存储结果是：" + mThreadLocal.get());

        new Thread("thread1") {
            @Override
            public void run() {
                super.run();
                mThreadLocal.set(false);
                Log.i("ruxing", "ThreadLocal存储结果是：" + mThreadLocal.get());
            }
        }.start();

        new Thread("thread2") {
            @Override
            public void run() {
                super.run();
                Log.i("ruxing", "ThreadLocal存储结果是：" + mThreadLocal.get());
            }
        }.start();
    }

打印结果是：

可以看到，不同线程访问同一个ThreadLocal对象之后取到的值是不一样的。具体原因是：

1、每一个线程都有一个ThreadLocal下的ThreadLocalMap对象threadLocals:

Thread.java

/* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

2、ThreadLocal调用get方法存储数据的时候，首先获取当前线程下的ThreadLocalMap对象，如果当前线程下的ThreadLocalMap对象为空，创建ThreadLocalMap对象并赋值给线程的成员变量threadLocals，如果不为空直接存储数据。

ThreadLocal.set()：

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

2.1、ThreadLocalMap对象为空，创建ThreadLocalMap对象：创建一个长度为INITIAL_CAPACITY=16的table数组，用于存储当前线程下所有的ThreadLocal实例对象数据。因为ThreadLocalMap是static，所以每个线程中

ThreadLocal.ThreadLocalMap构造方法：

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

2.2、ThreadLocalMap对象不为空，调用ThreadLocalMap.set()方法存储数据，将数据存储到ThreadLocal.ThreadLocalMap的table数组中。

ThreadLocal.ThreadLocalMap.set()：

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

通过2.1、2.2，可以看到，ThreadLocal存储数据的原理其实就是向ThreadLocal.ThreadLocalMap下的table数组中存储数据，由于ThreadLocalMap定义的是static类型的，所以同一个线程内所有创建的ThreadLocal对象都共用一个table数组，存储在table数组的不同位置，存储时的key值就是ThreadLocal对象的HashCode；不同线程访问的是不同的table数组，将数据存储在不同的table数组中。

3、ThreadLocal调用get方法读取数据的时候，也是读取的ThreadLocalMap中的table数组中的值，这就保证了不同线程之间获取的值不同。

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

通过以上可以知道：

1）同一线程内所有的ThreadLocal对象存储的数据都放在同一个table数组中；

2）不同线程有不同的table数组存储数据。