[java并发编程] ThreadLocal详解

前言：
我们在多线程编程的时候，会使用到共享变量，为了保证多个线程对共享变量的安全访问，通常会使用synchronizedl来保证同一时刻只有一个线程对共享变量进行操作。在这种情况下，就可以将类变量放到ThreadLocal类型的对象中，使变量在每个线程中都有独立拷贝，不会出现一个线程读取变量而被另一个线程修改的现象。

ThreadLocal

ThreadLocal是JDK底层提供的一个解决多线程并发问题的工具类，他为每个线程提供了一个本地的副本变量机制，实现了和其他线程隔离，并且这种变量只在本线程的生命周期内起作用，可以减少同一个线程内多个方法之间的公共变量传递的复杂度。

ThreadLocal应用

ThreadLocal主要解决两类问题：

• 并发问题：使用ThreadLocal代替synchronized来保证线程安全，同步机制采用空间换时间仅先提供一份变量，各个线程轮流访问，后者每个线程都持有一份变量，访问时互不影响。
• 数据存储问题：ThreadLocal为变量在每个线程种创建了一个副本，所以每个线程都可以访问自己内部的副本变量。

ThreadLocal的实现原理

ThreadLocal主要分为2个部分：第一部分是它的一些成员属性，这部分主要和计算哈希值相关的。另一部分是它对外提供的几个API,这些方法可以操作它自己内部非常重要的内部类。

早期的 ThreadLocal 是每个 ThreadLocal 类都会去创建一个 Map，然后以线程 id作为 key，要存储的局部变量作为 value，这样就可以达到线程隔离的效果。但是这样的话,这个存储数量是 Thread 的数量决定,当线程销毁之后还要去维护 Map中的那份 k-v 让它也随之销毁。后来的版本是这么设计的：每个线程都维护一个 ThreadlocalMap 哈希表(类似HashMap),这个哈希表的 key 是 ThreadLocal 对象本身，value 是要存储的局部副本值，这样的话存储数量是 ThreadLocal 的数量决定的。当 Thread 销毁之后,ThreadLocalMap 也会被随之销毁,减少内存占用。
而ThreadLocalMap的实现原理跟HashMap 差不多，内部有一个 Entry 数组，一个 Entry通常至少包括key,value , 特殊的是这个Entry继承了 WeakReference 也就是说它是弱引用的所以可能会有 内存泄露 的情况。这个后面再说。ThreadLocal 负责管理 ThreadLocalMap ，包括插入，删除 等等.另一方面来说 ThreadLocal 基本上就相当于 门面设计模式中的一个Facade类。key就是 ThreadLocal 对象自己，同时，很重要的一点:就ThreadLocal把 Map 存储在当前线程对象里面
我们来看看部分ThreadLocal源代码：

public class ThreadLocal<T> {
    /**
     * 自定义哈希码(ThreadLocalMaps的),降低哈希冲突
     */
    private final int threadLocalHashCode = nextHashCode();

    /**
     * 生成下一个哈希码的hashCode,操作是原子的,从0开始
     */
    private static AtomicInteger nextHashCode =
        new AtomicInteger();

    /**
     * 连续分配的两个ThreadLocal实例的threadLocalHashCode值的增量
     */
    private static final int HASH_INCREMENT = 0x61c88647;

    /**
     * 返回下一个哈希码的hashCode,此方法是一个原子类不停地去加上斐波那契散列数,使得哈希值分布均匀
     */
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

}

再来看一看ThreadLocal的方法：

    /**
     * 此方法第一次调用发生在当线程通过 {@link #get} 方法访问此线程的ThreadLocal值时
     * 除非线程先调用了 {@link #set}，在这种情况下,{@code initialValue} 方法才不会被这个线程调用
     * 通常情况下,每个线程最多调用1次这个方法,但是也可能再次调用,比如 {@link #remove} 被调用后,调用get
     * 这个方法仅仅简单返回null{@code null}; 如果程序想要它返回除了null之外的初始值,必须继承重写此方法,
     * 通常使用匿名内部类的方式实现
     * @return 返回当前ThreadLocal的初始值 null
     */
    protected T initialValue() {
        return null;
    }

    /**
     * 返回当前线程中保存ThreadLocal的值
     * 如果当前线程没有此ThreadLocal则通过 {@link #initialValue}方法进行初始化值
     * @return 
     */
    public T get() {
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取此线程对象中维护的`ThreadLocalMap`对象
        ThreadLocalMap map = getMap(t);
        // 如果Map存在
        if (map != null) {
            // 以当前ThreadLocal实例对象为key获取对应的存储实体e
            ThreadLocalMap.Entry e = map.getEntry(this);
            // 找到对应的存储实体e
            if (e != null) {
                @SuppressWarnings("unchecked")
                // 获取e对应的value值,也就是我们想要的当前线程对应此ThreadLocal的值
                T result = (T)e.value;
                return result;
            }
        }
        // 如果map不存在,证明此线程没有维护此ThreadlocalMap对象,进行一波初始化操作
        return setInitialValue();
    }

    /**
     * set的变样实现,用于初始化值initialValue
     * 用来代替防止用户重写set而无法初始化
     * @return 返回初始化后的值
     */
    private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        // 如果此map村咋洗,调用map,set设置此实体entry
        if (map != null)
            map.set(this, value);
        else
         // map不存在时,调用此方法进行ThreadLocalMap对象初始化并将此entry作为第一个值放进去
            createMap(t, value);
         // 返回设置的value值s
        return value;
    }

    /**
     * 设置此线程对应的ThreadLocal的值,大多数子类不需要重写此方法,
     * 只需要依赖{@link #initialValue} 方法代替设置当前线程对应的ThreadLocal值
     * @param 将要保存在当前线程对应的ThreadLocal值
     * 1. 获取当前线程`Thread`对象,进而获取此线程对象中维护的`ThreadLocalMap`对象
     *2. 判断当前的`ThreadLocalMap`是否存在,如果存在就直接调用map.set设置entry,如果不存在就调用`createMap`进行`ThreadLocalMap`对象的初始化,并将此实体`entry`作为第一个值存放到`ThreadLocalMap`中。
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        // 获取当前线程的ThreadLocalMap实例
        ThreadLocalMap map = getMap(t);
        // 存在就设置此entry
        if (map != null)
            map.set(this, value);
        else
        // 不存在就进行对象初始化并设置entry作为第一个值存入ThreadLocalMap中
            createMap(t, value);
    }

    /**
     * 删除当前线程中保存ThreadLocal对应的实体entry
     * 如果此ThreadLocal变量在当前线程中调用{@linkplain #get read} 方法
     * 则会通过调用{@link #initialValue} 方法进行初始化
     * 除非此值value是通过当前线程内置调用set方法设置
     * 这可能导致在当前线程中多次调用initialValue方法初始化
     * 1. 获取当前线程Thread对象，进而获取此线程对象中维护的ThreadLocalMap对象。
     * 2.  判断`ThreadLocalMap`是否存在,如果存在,调用map.remove,以当前的`ThreadLocal`为key删除对应的`entry`
     */
     public void remove() {
         // 获取当前线程Thread对象,进而获取此线程对象中维护的`ThreadLocalMap`对象
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
         // 如果`ThreadLocalMap`存在调用remove方法删除之,当前ThreadLocal对象为key
             m.remove(this);
     }

    /**
     * 获取当前对象Thread对应维护的ThreadLocalMap
     * @param  当前线程
     * @return 对应的ThreadLocalMap
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

再来看看ThreadLocal的内部类ThreadLocalMap，ThreadLocalMap其内部利用Entry来实现的key-value的存储，类似HashMap的结构，如下代码，我们可以看出Entry的key就是ThreadLocal，而value就是值。同时Entry也是继承WeakReference，所以说Entry所对应得key得引用为一个弱引用。

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

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

ThreadLocal代码样例

通过一个例子来解释一下ThreadLocal得使用：

package com.asong.cloud;

public class TestThreadLocal {
    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        for (int i = 0; i <10 ; i++) {
            final int final1 = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    threadLocal.set(final1);
                    try {
                        Thread.sleep(1000);
                    }catch (Exception e)
                    {
                        e.printStackTrace();
                    }
                    System.out.println("ThreadLocal: " + threadLocal.get());
                }
            }).start();
        }
    }
}

运行结果如下：