聊一聊线程变量绑定之ThreadLocal

山行AI

发布于 2019-12-19 11:30:01

8670

发布于 2019-12-19 11:30:01

文章被收录于专栏：山行AI山行AI

当使用 ThreadLocal 维护变量的时候为每一个使用该变量的线程提供一个独立的变量副本，即每个线程内部都会有一个该变量，这样同时多个线程访问该变量并不会彼此相互影响，因此他们使用的都是自己从内存中拷贝过来的变量的副本，这样就不存在线程安全问题，也不会影响程序的执行性能。但是要注意，虽然 ThreadLocal 能够解决上面说的问题，但是由于在每个线程中都创建了副本，所以要考虑它对资源的消耗，比如内存的占用会比不使用 ThreadLocal 要大。

示例

@Test
    public void testSimpleThreadLocal() throws InterruptedException {
        ThreadLocal threadLocal = new ThreadLocal();
        threadLocal.set("simple thread local in main thread!");
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("inner thread:" + threadLocal.get());
                threadLocal.set("simple ThreadLocal in thread!");
                System.out.println("inner thread:" + threadLocal.get());
            }
        });
        thread.start();
        thread.join();
        System.out.println(threadLocal.get());
    }

输出结果为:

inner thread:null
inner thread:simple ThreadLocal in thread!
simple thread local in main thread!

可以看到，在 thread1 中可以通过 threadLocal 来进行变量的保存，在整个线程的上下文中都可以获取到这个变量的值。就是为每一个使用该变量的线程都提供一个变量值的副本，每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。main 线程和 thread1 线程之间互不影响。
另一方面，它也有一定的局限性，thread1 线程是 main 线程的子线程，但是父线程中的 threadLocal 变量与子线程是没有达到共享的效果的。当然，在它的子类 InheritableThreadLocal 实现了这个特性。在聊 InheritableThreadLocal 时会进一步讲解。

原理

这里我们从源码角度来聊一聊 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);
}

先看下 getMap 方法:

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

要了解这个，我们需要先看一看 Thread 类中的两个属性:

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

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

这两个参数在 new Thread 时会进行初始化:

public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }

   private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {
    .............
     if (parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    ............
    }

需要关注的是在初始化时会将父线程的 inheritableThreadLocals 赋给子线程(这点在后面讲到 inheritableThreadLocals 时特别有用)。

我们再回过来看 set 方法，在 getMap 时第一次获取到的值为 null，继而会执行 createMap 方法:

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

会给当前线程的 threadLocals 变量赋一个新创建的 ThreadLocalMap 对象。传入的是 threadLocal 变量和要 set 的值，我们看一下 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);
    }

关于这个构造我们来聊以下几点:

INITIAL_CAPACITY 初始值是 16，是 2 的指数倍。取这个值是因为在 2 的指数倍情况下 hash 值是完全散列的(无 hash 冲突)。
table 为 Entry 类型的数组。
firstKey.threadLocalHashCode 的值是一直增加的不会重复的值，用于取 table 的下标来用的。它的初始值具说和斐波那契数列（和黄金分割数）有关。(根号 5-1)*2 的 31 次方，转换成 long 类型就是 2654435769，转换成 int 类型就是-1640531527（这点说明来自:cnblogs.com/dennyzhangdd/p/7978455.html)
Entry extends WeakReference<threadlocal</threadlocal

这里是不是想到了 hashmap 中的用法——用 key 的 hashcode 对容量减一取&操作的结果应该是该值在 map 中的索引位置。前提是容量是 2 的指数倍。

而当第二次调用 ThreadLocal 的 set(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);
    //相当于i < len - 1的一个遍历
    for (Entry e = tab[i];
            e != null;
            e = tab[i = nextIndex(i, len)]) {
        //e的值是tab[i]位置上的那个Entry
        ThreadLocal<?> k = e.get();
        //条件一:如果这个ThreadLocal的引用已经存在时，则直接更改Entry的value值。
        if (k == key) {
            e.value = value;
            return;
        }
        //条件二:e!=null成立，证明这个Entry之前存在，但是现在这个Entry中的key为空时
        if (k == null) {
            //如果key为null,用新key、value覆盖，同时清理历史key=null的陈旧数据
            //在replaceStaleEntry中会从i位置开始向前和向后清理table上的key为null的Entry，减小空间占用
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    //如果不符合上述两个条件时，直接放入位置i
    tab[i] = new Entry(key, value);
    int sz = ++size;
    //1. 清理一些slot
    //2. 是否需要扩容，如果需要扩容则需要将老的数据进行rehash重新放入容器中
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}


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

这里需要注意一点是，当两个 hash 冲突时会有覆盖发生。

get 方法

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

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 T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

对于 get 方法我们做以下几点讲解:

getMap 方法与上面的 set 方法同解。
如果没有 set 过值，也就是 map 为 null 时会调用 setInitialValue 方法，这个方法会调用 initialValue 方法，这个方法在后面的其他两种 ThreadLocal 实现中你会越来越熟悉的。当然，在这里初始的值为 null。
getEntry 方法也十分地简单，通过 ThreadLocal 实例中的 threadLocalHashCode 值定位到它所在的 Entry 在 table 中的下标 i 的值，然后从 table 中取出 Entry，然后通过 ThreadLocal 实例取值即可。