ThreadLocal源码分析

线程局部变量-ThreadLocal源码分析

相信很多使用Java语言的同学在开发过程中都用到过ThreadLocal，或者是在面试时被问到过关于ThreadLocal的问题。不管是在开发中使用还是面试时回答，你是否足够了解ThreadLocal呢？今天我们通过分析源码的方式来重新学习ThreadLocal。

1、什么是ThreadLocal？

面试时面试官问关于ThreadLocal的问题，我觉得他一定会这样问。那么，该如何回答？不妨看下源码中对ThreadLocal的介绍，如下：

This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its {@code get or {@code set} method) has its own, independently initialized copy of the variable. {@code ThreadLocal} instances are typically private static fields in classes that wish to associate state with a thread (e.g., a user ID or Transaction ID).

此类（ThreadLocal）提供了线程局部变量。这些变量与对应的正常变量的不同之处在于，每个线程访问（通过get和set方法）的是自己独立初始化的变量副本。ThreadLocal实例通常是希望将状态与线程（例如，用户ID或事务ID）关联的类中的私有静态字段。
简单总结就是，ThreadLocal是提供线程局部变量的工具类，线程局部变量是每一个线程独有的。这里可以引申出一些问题：

• ThreadLocal是如何提供线程局部变量？
• 线程局部变量又是如何保存的？

开始分析ThreadLocal源码之前，先看下Thread类中threadLocals属性。

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

注释简洁易懂，与线程相关的ThreadLocal值，这个Map由ThreadLocal来维护。threadLocals是ThreadLocalMap类型，由此可以推断出，ThreadLocal是维护线程局部变量的工具类，线程局部变量其实是保存在ThreadLocal的内部类ThreadLocalMap的实例中，每个Thread实例拥有独立的线程局部变量。
接下来，我们看下ThreadLocal的源码。

2、ThreadLocal的属性

    //每一个ThreadLocal实例对应的hashcode值
 	private final int threadLocalHashCode = nextHashCode();

    //下一个hashcode值
    private static AtomicInteger nextHashCode =
        new AtomicInteger();

    //hash increment
    private static final int HASH_INCREMENT = 0x61c88647;

ThreadLocal并没有重写hashcode()，而是通过nextHashCode（原子操作类AtomicInteger实例）和HASH_INCREMENT来计算出每一个ThreadLocal实例对应的hashcode值，这个在nextHashCode()中有体现，这里不再说明。

3、ThreadLocal的核心方法

ThreadLocal主要提供了以下三个核心方法：

1. set(T value)：为当前线程设置线程局部变量
2. get()：获取当前线程的局部线程变量
3. remove()：移除当前线程的局部线程变量

3.1、set(T value)

set(T value)逻辑如下：

1. 获取当前线程对象
2. 根据当然线程对象获取当前线程中的ThreadLocalMap实例
3. 如果map不为空，则直接为当前线程对象设置线程局部变量
4. 如果map为空，为当前线程对象创建ThreadLocalMap实例并设置线程局部变量

   public void set(T value) {
        //获取当前线程对象
        Thread t = Thread.currentThread();
        //获取ThreadLocalMap实例
        ThreadLocalMap map = getMap(t);
        if (map != null)
            //为当前线程对象设置线程局部变量
            map.set(this, value);
        else
            //为当前线程对象创建ThreadLocalMap实例并设置线程局部变量
            createMap(t, value);
    }

3.2、get()

get()逻辑如下：

1. 获取当前线程对象
2. 根据当然线程对象获取当前线程中的ThreadLocalMap实例
3. 如果map不为空，则根据当前ThreadLocal实例获取对应的线程局部变量值
4. 如果map为空，为当前线程对象初始化线程局部变量

    public T get() {
         //获取当前线程对象
        Thread t = Thread.currentThread();
         //根据当然线程对象获取当前线程中的ThreadLocalMap实例
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            //根据当前ThreadLocal实例获取对应的线程局部变量值
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        //为当前线程对象初始化线程局部变量
        return setInitialValue();
    }

3.3、remove()

get()逻辑如下：

1. 根据当前线程对象获取当前线程中的ThreadLocalMap实例
2. 如果map不为空，根据当前ThreadLocal实例移除对应的线程局部变量

    public void remove() {
         //根据当前线程对象获取当前线程中的ThreadLocalMap实例
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             //根据当前ThreadLocal实例移除对应的线程局部变量
             m.remove(this);
     }

在三个核心方法逻辑中，也调用了ThreadLocal的其他方法以及内部类ThreadLocalMap的方法。ThreadLocalMap的方法下文中再做详细介绍，先来看下ThreadLocal的其他方法。

4、ThreadLocal的其他方法

这里主要介绍以下几个方法：

1. getMap(Thread t)：根据当前线程对象获取当前线程中的ThreadLocalMap实例
2. createMap(Thread t, T firstValue)：为当前线程对象创建ThreadLocalMap实例并设置线程局部变量
3. setInitialValue()：为当前线程对象初始化线程局部变量
4. initialValue()：获取初始化值

4.1、getMap(Thread t)

getMap(Thread t)逻辑：返回当前线程对象的ThreadLocalMap实例

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

4.2、createMap(Thread t, T firstValue)

createMap(Thread t, T firstValue)逻辑：为当前线程对象创建ThreadLocalMap实例并设置线程局部变量

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

4.3、setInitialValue()

setInitialValue()逻辑如下：

1. 获取初始化值
2. 获取当前线程对象
3. 根据当前线程对象获取当前线程中的ThreadLocalMap实例
4. 如果map不为空，则直接为当前线程对象设置线程局部变量
5. 如果map为空，为当前线程对象创建ThreadLocalMap实例并设置线程局部变量

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

4.4、initialValue()

initialValue()逻辑：默认返回一个null值（此方法可以重写）

    protected T initialValue() {
        return null;
    }

5、ThreadLocalMap

ThreadLocalMap是ThreadLocal的内部类，是真正存储线程局部变量的数据结构。ThreadLocalMap内部通过Entry维护了一个K-V类型的哈希表，K的类型限定了只能是ThreadLocal类型，V可以使任意类型。Entry的定义如下：

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

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

通过源码可以看出，Entry的父类是WeakReference>，这里也限定了Entry的K是弱引用类型，只能存活一个垃圾回收周期。
ThreadLocalMap提供了三个核心方法，如下：

1. set(ThreadLocal key, Object value)：根据key、value设置线程局部变量
2. getEntry(ThreadLocal key)：根据key获取Entry
3. remove(ThreadLocal key)：根据key移除线程局部变量

5.1、set(ThreadLocal key, Object value)

        private void set(ThreadLocal key, Object value) {
            //获取entry数组
            Entry[] tab = table;
            int len = tab.length;
            //根据key的hashcode和数组长度计算key在数组中的位置
            int i = key.threadLocalHashCode & (len-1);
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal k = e.get();
                //如果key已存在，则更新对应的value
                if (k == key) {
                    e.value = value;
                    return;
                }
                //k对应的entry的K、V分别替换为key和value
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
            //使用key、value创建一个新的entry并放入entry数组
            tab[i] = new Entry(key, value);
            //数组长度加1
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

5.2、 getEntry(ThreadLocal key)

        private Entry getEntry(ThreadLocal key) {
            //根据key的hashcode和数组长度计算key在数组中的位置
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            //找到key对应的entry
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }

5.3、remove(ThreadLocal key)

       private void remove(ThreadLocal key) {
            //获取entry数组
            Entry[] tab = table;
            int len = tab.length;
            //根据key的hashcode和数组长度计算key在数组中的位置
            int i = key.threadLocalHashCode & (len-1);
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                if (e.get() == key) {
                    //找到key对应的entry后清空
                    e.clear();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }

6、总结

至此，我们通过分析源码分方式学习了ThreadLocal。简单做下总结：

1. ThreadLocal是一个工具类，与线程相关的线程局部变量是由ThreadLocal来维护的。
2. 每一个线程都有一个threadLocals属性，线程局部变量就保存在其中。这个属性是ThreadLocalMap类型，ThreadLocalMap内部通过Entry维护了一个K-V类型的哈希表，K为ThreadLoca类型，V为Object类型。
3. 一个ThreadLocal实例只能维护一个线程局部变量，如果需要多个不同类型的线程局部线程变量，就需要创建多个ThreadLocal实例。

由于笔主水平有限，笔误或者不当之处还请批评指正。