多线程 - ThreadLocal

一 ThreadLocal定义

ThreadLocal是线程局部变量，是一种保存线程私有信息的机制。

通过 ThreadLocal 可以为每个线程提供线程独有的变量拷贝，用来保证每个线程间访问的变量互不影响，这种变量只在线程的生命周期中起作用，在本线程内随地可取可用，以减少同一个线程内多函数间变量传递的复杂度。

ThreadLocal是用来解决java多线程程序中并发问题的一种方式，除ThreadLocal外，我们也可以通过加锁(eg: synchorinized )的机制来保证变量的线程安全性，但加锁会影响到程序的执行效率，此时ThradLocal就可以派上用场；

二 使用场景

1、Spring事务隔离基于 ThreadLocal 和 AOP 实现，具体源码参见 TransactionSynchronizationManager；

2、Spring使用 ThreadLocal 来保证单个线程中的数据库操作使用的是同一个数据库连接；

3、session管理；

4、业务中涉及横跨多方法、多层级调用时将请求参数放入ThreadLocal，防止过渡传参，如用户id 从controller 透传到 dao层等；

5、基于ThreadLocal 实现 SimpleDateFormat 线程安全性；

6、... ...

三 API

// 获取当前线程中的共享变量的副本
public T get() {}

// 设置当前线程中变量的副本值
public void set(T value) {}

// 移除当前线程中变量的副本，回收内存；
// 其实这个不是必须要调用的，因为当线程失效之后，这些内存会自动释放
// 未避免出现内存泄露问题，建议在线程结束前手动调用该方法清空数据
public void remove() {}

// get调用时的默认值，默认返回null
// protected方法；方便实际业务中根据实际需要重写方法
protected T initialValue() {}

调用示例：

        ThreadLocal<String> tl = new ThreadLocal<>();
        
        tl.set("zhangsan");
        
        System.out.println(tl.get());
        
        tl.remove();

set()

源码示例：

    public void set(T value) {
        Thread t = Thread.currentThread();  // 获取当前线程
        ThreadLocal.ThreadLocalMap map = getMap(t);  // 获取当前线程 ThreadLocalMap 对象
        if (map != null)
            map.set(this, value);  // 不为空则set
        else
            createMap(t, value);  // 为空则初始化当前线程 ThreadLocalMap
    }

set()方法实现比较简单，主要关注其中的 ThreadLocalMap 对象，ThradLocalMap对象是获取自当前线程的一个 threadLocals 变量：

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

public class Thread implements Runnable {

    ... ... 

    /* 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;

每个线程维护了自己的 threadLocals，在线程创建 TreadLocal 及保存变量时，实际上变量是存在于当前线程自己的threadLocals变量里的，其他的线程自然无法获取当前线程的变量，也就实现了数据隔离；

再来看看ThreadLocalMap：

static class ThreadLocalMap {

        // 基于弱引用的Entry对象
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

        // 初始容量 默认16
        private static final int INITIAL_CAPACITY = 16;

        // 数组结构存储数据
        private Entry[] table;

        /** The number of entries in the table. */
        private int size = 0;

        /** The next size value at which to resize. */
        private int threshold; // Default to 0

        // resize门限 2/3
        private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }

由上述源码也可以看出，ThreadLocal并没有存储任何值，它只是用来当ThreadLocalMap的key，让线程可以拿到对应的value。

ThreadLocalMap中有个Entry数组，之所以用数据是因为一个线程中可能存在多个不同的ThreadLocal来存储不同的对象，所以此处用数组来存储；

ThreadLocalMap的数据结构有点像HashMap，但它并没有实现Map接口，而且他的Entry继承了 WeakReference 弱引用，也没有HashMap中的next，所以也就不存在链表，因此当存在hash冲突时，ThreadLocalMap采用线性探测的方式来解决hash冲突。参见源码：

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

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

                // 如果当前位置不为空，且key即为当前threadlocal，则刷新value
                if (k == key) {
                    e.value = value;
                    return;
                }

                // 如果当前位置为空，则初始化一个Entry对象
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

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

ThreadlocalMap在set元素时会先获取key即当前ThreadLocal的threadLocalHashCode，并根据threadLocalHashCode的值定位到元素在table中的位置：

    1、如果当前位置为空，则初始化一个Entry对象放在当前位置上；

    2、如果当前位置不为空，且key即为当前threadlocal，则刷新value;

    3、如果当前为空不为空，且key不为当前threadlocal，则继续迭代table，寻找下一个空位置；

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 Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
        Entry[] tab = table;
        int len = tab.length;

        // 根据key的hashcode获取在table中的下标值，循环查找元素对比key是否相等
        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;
    }

与set()类似，同样是先获取到当前线程的ThreadLocalMap，然后在 map.getEntry()中通过 threadlocal 的 threadLocalHashCode定位到当前 threadlocal 在table中的位置，循环查找元素对比key，捞取数据； 

内存泄露问题

回到ThreadLocalMap的Entry对象，上面提到Entry对象继承了 WeakReference 弱引用，参见弱引用的定义：

弱引用（Weak Reference）：弱引用的对象拥有更短暂的生命周期。
在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，
不管当前内存空间足够与否，都会回收它的内存

这就导致一个问题，即当前 threadlocal 在没有外部引用的时，如果此时触发GC，则Entry的key即threadlocal会被回收， 而如果创建当前Theadlocal的线程一直运行，则Entry的value对象有可能一直得不到回收，久而久之就有可能产生内存泄露；

所以为了避免产生上述内存溢出问题，在使用threadlocal需记得在线程代码最后调用 ThreadLocal 中的 remove() 方法将值清空，这样在触发GC时就会将值回收掉，避免内存泄露；

父子线程共享ThreaLocal

java.lang.Thread中提供了 inheritableThreadLocals 属性用以支持获取父线程线程变量

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

代码示例：

    public static void main(String[] args) {
        ThreadLocal<String> tl = new InheritableThreadLocal<>();
        tl.set("zhangsan");

        Thread child = new Thread() {
            @Override
            public void run() {
                super.run();
                System.out.println(tl.get());
            }
        };

        child.start();
    }

实现原理参见 Thread 类的 init 方法：

    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 属性赋给子线程即可实现父子线程共享 threadlocal；