ThreadLocal 的作用和实现原理

一、简介

ThreadLocal类用来提供线程内部的局部变量，并且这些变量依靠线程独立存在。通常情况下，ThreadLocal实例在类文件中被定义为private static变量，具体使用可根据需求构造。在Android源码中典型应用就是被用来保存Looper对象，从而实现消息机制。

二、示例用法

ThreadLocal对象提供了get、set、remove三个方法用于获取、修改和删除变量，最常用的为get、set方法。

public class TestThreadLocal {
    public static void main(String args[]){

        // 声明 ThreadLocal对象
        ThreadLocal<String> mThreadLocal = new ThreadLocal<String>();
        ThreadLocal<String> mThreadLocal2 = new ThreadLocal<String>();

        // 在主线程、子线程1、子线程2中去设置访问它的值
        mThreadLocal.set("父");
        mThreadLocal2.set("父2");

        System.out.println("线程（"+Thread.currentThread().getName()+"）    " + mThreadLocal.get());
        System.out.println("线程（"+Thread.currentThread().getName()+"）    " + mThreadLocal2.get());

        new Thread("#1"){
            @Override
            public void run() {
                mThreadLocal.set("1");
                System.out.println("线程（"+this.getName()+"）      " + mThreadLocal.get());
                mThreadLocal.remove();
                System.out.println("线程（"+this.getName()+"）      " + mThreadLocal.get());

            }
        }.start();

        new Thread("#2"){
            @Override
            public void run() {
                System.out.println("线程（"+this.getName()+"）      " + mThreadLocal.get());
            }
        }.start();

    }
}

打印结果

线程（main）    父
线程（main）    父2
线程（#1）      1
线程（#2）      null
线程（#1）      null

三、实现原理

先看一张别人的图

1.Thread中用ThreadLocal.ThreadLocalMap数据结构存储局部变量

    //局部变量存储结构（对应于ThreadLocal）
    ThreadLocal.ThreadLocalMap threadLocals = null;
    //原理同threadLocals，线程创建时可继承所在线程数据（对应于InheritableThreadLocal）
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

2.ThreadLocal.ThreadLocalMap内部用Entry[] table存储数据，并提供getEntry(ThreadLocal<?> key）、set(ThreadLocal<?> key, Object value)和remove(ThreadLocal<?> key)方法获取、设置、删除数据。其中Entry[] table的下标为key.threadLocalHashCode & (table.length - 1)，在table中元素到达其容量1/2时，会扩容至前容量的两倍。

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

        //有该ThreadLocal的对应值就替换，没有就新建
        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();//扩容
        }

        /**
         * Remove the entry for key.
         */
        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;
                }
            }
        }

3.Entry是数据的载体，以弱引用形式保存ThreadLocal对象

static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;//真正的值

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

4.ThreadLocal的get、set、remove方法中获取当前线程对象，并通过线程对象获取其ThreadLocalMap，再通过ThreadLocalMap的get、set、remove方法完成实际逻辑。源码如下：
①getMap方法是直接获取线程的threadLocals 中的局部变量（如步骤1中所示）

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

②ThreadLocal的get、set、remove其实都是通过getMap获取当前线程的ThreadLocalMap 对象，并调用其对应的方法

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

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

四、InheritableThreadLocal

InheritableThreadLocal是ThreadLocal的子类，关键的不同是getMap的实现不同，他的getMap获取的是线程中的inheritableThreadLocals 对象，而inheritableThreadLocals在新线程被创建时会调用init2方法，并将新线程被创建操作所在线程的inheritableThreadLocals中的值复制给新线程，因此新线程会继承环境线程的数据。

    private void init2(Thread parent) {
        this.contextClassLoader = parent.getContextClassLoader();
        this.inheritedAccessControlContext = AccessController.getContext();
        if (parent.inheritableThreadLocals != null) {
            this.inheritableThreadLocals = ThreadLocal.createInheritedMap(
                    parent.inheritableThreadLocals);
        }
    }

测试代码如下：

public class TestThreadLocal {
    public static void main(String args[]){

        final InheritableThreadLocal threadLocal = new InheritableThreadLocal();
        final InheritableThreadLocal threadLocal2 = new InheritableThreadLocal();
        System.out.println("线程（"+Thread.currentThread().getName()+"）  无设定过值      ："+threadLocal.get());
        threadLocal2.set("value");
        Thread myThread = new Thread("父"){
            @Override
            public void run() {
                super.run();
                System.out.println("线程（"+this.getName()+"）    无设定过值      ："+threadLocal.get());

                threadLocal.set("2");
                System.out.println("线程（"+this.getName()+"）    [父]设值为2     ："+threadLocal.get());
                System.out.println("线程（"+this.getName()+"）    threadLocal2    ："+threadLocal2.get());


                Thread t = new Thread("子") {
                    @Override
                    public void run() {
                        super.run();
                        System.out.println("线程（"+this.getName()+"）    [父]中设值为2   ："+threadLocal.get());
                        threadLocal.set("3");
                        System.out.println("线程（"+this.getName()+"）    [子]中设值为3   ："+threadLocal.get());

                    }
                };
                t.start();

            }
        };
        myThread.start();



    }
}

打印结果为：

线程（main）  无设定过值      ：null
线程（父）    无设定过值      ：null
线程（父）    [父]设值为2     ：2
线程（父）    threadLocal2    ：value
线程（子）    [父]中设值为2   ：2
线程（子）    [子]中设值为3   ：3

五、参考文献

1.JDK1.8源码
2.https://allenwu.itscoder.com/threadlocal-source