线程封闭概念

多线程访问共享数据为了安全性通常需要同步，如果仅在单线程内访问数据就不需要同步，这种避免共享数据的技术称为线程封闭。

ThreadLocal

JDK提供ThreadLocal类防止线程内的可变变量的共享，通过ThreadLocal类可以保证线程特有的变量封闭在线程内而不会逸出到该线程外。

初始化ThreadLocal

• 方式一，重写父类函数

ThreadLocal<Object> localVariable = new ThreadLocal<Object>(){
    protected Object initialValue() {
        return "abcd2"; 
    };
};

这种方式下，给ThreadLocal添加了一个默认值，在ThreadLocal调用get方法取值时,如果并未调用set方法设置新值时会调用setInitialValue()方法:

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

可以看到setInitialValue内部将this指针指向的当前ThreadLocal作为键，value作为值，插入到了ThreadLocalMap中。

• 方式二，调用set方法

ThreadLocal<Object> trLocal = new ThreadLocal<>();
localVariable.set("abcd");

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

这种方式与在ThreadLocal重写initialValue方法的区别是，不会将值的设置推迟到get方法的执行。

ThreadLocalMap 的创建

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

在Thread类内部有一个ThreadLocal.ThreadLocalMap的threadLocals变量，该变量在createMap方法的调用下被赋值一个新的ThreadLocalMap的实例。

ThreadLocal.png

static class ThreadLocalMap {
        static class Entry extends WeakReference<ThreadLocal<?>> {
            Object value;

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

        private Entry[] table;
        private static final int INITIAL_CAPACITY = 16;

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

ThreadLocalMap相当于线程本地变量的映射表。内部由Entry[]数组实现键值对的保存，其中键为ThreadLocal，值为线程本地变量。该数组初始值INITIAL_CAPACITY是16。

ThreadLocalMap 加入键值对

        private void set(ThreadLocal<?> key, Object value) {

            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1); @1

            for (Entry e = tab[i]; 
                 e != null;@2
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                if (k == key) { @3
                    e.value = value;
                    return;
                }

                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value); @2
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

@1 先通过ThreadLocal计算出hashCode，该hashCode在ThreadLocal由静态共享的AtomicInteger每次自增HASH_INCREMENT(0x61c88647)实现。根据hashCode算出键对应Entry[]数组的位置i。

@2 Entry[i]为空，将ThreadLocal和value对象封装成一个Entry对象插入到数组的i位置上。如果插入后未清除无效元素后，并且已达到数组的边界，接下来会对数组扩容两倍(JDK 1.8)

@3 如果Entry[i]非空，如果Entry[i]上的键与加入的键相等，重新设置值的引用为新加入的值。

@4 如果Entry[i]上的键为空，说明该键值对已失效，调用replaceStaleEntry删除table中所有失效元素并将新的键值对插入数组。

@5 算出下一个数组中的位置，重复@2、@3、@4的步骤。

ThreadLocal 取值

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

先判断当前线程是否有ThreadLocalMap，若不存在调用setInitialValue方法返回initialValue方法返回的默认值。

若当前线程的ThreadLocalMap非空，调用ThreadLocalMap的getEntry方法取出Entry:

        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的哈希值，再由该哈希值按位与数组的长度计算出Entry的位置i。

如果Entry[i]非空并且它内部的弱引用ThreadLocal非空，将Entry返回并取它的value。否则调用getEntryAfterMiss方法继续从数组的下个位置寻找Entry。

原理小结

使用ThreadLocal将线程本地变量封装到了线程的ThreadLocalMap中，想要从ThreadLocal取值就必须经过线程本地的ThreadLocalMap,因此本线程外访问ThreadLocalMap是无效的，避免了对线程本地变量的干扰。