ThreadLocal原理分析

本文结构

• ThreadLocal简介 (简要说明ThreadLocal的作用)
• ThreadLocal实现原理（说明ThreadLocal的常用方法和原理）
• ThreadLocalMap的实现 (说明核心数据结构ThreadLocalMap的实现)

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可以避免共享资源的竞争，同时与不影响线程的隔离性。

通过threadLocal.set方法将对象实例保存在每个线程自己所拥有的threadLocalMap中，
这样每个线程使用自己保存的ThreadLocalMap对象，不会影响线程之间的隔离。

看到这里的第一眼我一直以为ThreadLocal是一个map，每一个线程都是一个key，对应一个value，但是是不正确的。正确的是每个线程持有一个ThreadLocalMap的副本，这个map的键是ThreadLocal对象，各个线程中同一key对应的值可以不一样。

ThreadLocal实现原理

---

ThreadLocal中的字段与构造方法

详细说明参考注释

public class ThreadLocal {
  
   //当前ThreadLocal对象的HashCode值，
   //通过这个值可以定位Entry对象在ThreadLocalMap中的位置
   //由nextHashCode计算得出
   private final int threadLocalHashCode = nextHashCode();

   //一个自动更新的AtomicInteger值，官方解释是会自动更新，怎么更新的不知道，
   //看完AtomicInteger源码回来填坑
   private static AtomicInteger nextHashCode =
       new AtomicInteger();

   //ThreadLocal的魔数
   //0x61c88647是斐波那契散列乘数,它的优点是通过它散列(hash)出来的结果分布会比较均匀，可以很大程度上避免hash冲突，
   private static final int HASH_INCREMENT = 0x61c88647;

   private static int nextHashCode() {
       //原子操作：将给定的两个值相加
       return nextHashCode.getAndAdd(HASH_INCREMENT);
   }

   /**
    * 返回当前线程变量的初始值
    * 这个方法仅在没有调用set方法的时候第一次调用get方法调用
    */
   protected T initialValue() {
       return null;
   }
   //构造方法
   public ThreadLocal() {
   }
  
   //创建ThreadLocalMap，
   //当前的ThreadLocal对象和value加入map当中
   //赋值给当前线程的threadLocals字段
   void createMap(Thread t, T firstValue) {
       t.threadLocals = new ThreadLocalMap(this, firstValue);
   }
.......
}

常用方法get()、set()、remove

get()方法

get()方法的源码，具体的代码解释请看注释

//返回当前线程中保存的与当前ThreadLocal相关的线程变量的值（有点绕，可以看代码注释）
public T get() {
   Thread t = Thread.currentThread();
   
   //返回当前线程的threadLocals字段的值，类型是ThreadLocalMap
   //暂时可以将ThreadLocalMap当作HashMap，下文解释
   ThreadLocalMap map = getMap(t);
   if (map != null) {

       //Entry也可以按照HashMap的entry理解
       //Entry保存了两个值，一个值是key，一个值是value
       //返回当前ThreadLocalMap中当前ThreadLcoal对应的Entry
       ThreadLocalMap.Entry e = map.getEntry(this);
       if (e != null) {
           @SuppressWarnings("unchecked")
           T result = (T)e.value;

           //返回Entry中对应的值
           return result;
       }
   }
   //如果当前线程的ThreadLocalMap不存在，则构造一个
   return setInitialValue();
}

getMap(Thread t) 方法

//返回当前线程的threadLocals字段的值，类型为ThreadLocalMap
ThreadLocalMap getMap(Thread t) {
       return t.threadLocals;
   }

getEntry(ThreadLocal key)方法

//table是一个数组，具体的可以看下文的ThreadLocalMap解释
//返回当前ThreadLocalMap中key对应的Entry

private Entry getEntry(ThreadLocal key) {
   //根据key值计算所属Entry所在的索引位置（同HashMap）
   
   int i = key.threadLocalHashCode & (table.length - 1);
   Entry e = table[i];
   //由于存在散列冲突，判断当前节点是否是对应的key的节点
   if (e != null && e.get() == key)
       //返回这个节点
       return e;
   else
       return getEntryAfterMiss(key, i, e);
}

setInitialValue()方法

 private T setInitialValue() {
     
     //在构造方法部分有写，返回一个初始值，
     //默认情况（没有被子类重写）下是一个null值
     T value = initialValue();
     Thread t = Thread.currentThread();
     ThreadLocalMap map = getMap(t);
     //再次判断当前线程中threadLocals字段是否为空值
     if (map != null)
         //set可以看作HashMap中的put
         map.set(this, value);
     else
         //当map为null时
         //构造一个ThreadLocalMap，
         //并以自身为键，initialValue()的结果为值插入ThreadLocalMap
         //并赋值给当前线程的threadLocals字段
         createMap(t, value);
     return value;
 }

createMap方法

void createMap(Thread t, T firstValue) {
 //调用THreadLocalMap的构造方法
 //构造一个ThreadLocalMap，
 //使用给定的值构造一个存储的实例（Entry的对象）存储到map中
 //并保存到thread的threadLocals字段中
 t.threadLocals = new ThreadLocalMap(this, firstValue);
}

        从get()方法中大概可以看出ThreadLocalMap是一个以ThreadLocal对象为键一个Map，并且这个ThreadLocalMap对象由Thread类维护，并保存在threadLocals字段中，不同的ThreadLocal对象可以以自身为键访问这个Map中对应位置的值。

        当第一次调用get()(之前没有调用过set()或者调用了remove())时，会调`initialValue()添加当前ThreadLocal对象对应的值为null并返回。

set()方法

set()方法的源码，具体的代码的解释请看注释

/**
* 设定当前线程的线程变量的副本为指定值
* 子类一般不用重写这个方法
* override this method, relying solely on the {@link #initialValue}
* method to set the values of thread-locals.
*
* @param value the value to be stored in the current thread's copy of
*        this thread-local.
*/
public void set(T value) {
   Thread t = Thread.currentThread();
   //返回当前线程的threadLocals字段的值，类型是ThreadLocalMap，同get()方法
   ThreadLocalMap map = getMap(t);
   //同get()一样 判断当前线程的threadLocals字段的是否为null
   if (map != null)
       //不为null，设置当前ThreadLocal（key）对应的值（value）为指定的value
       map.set(this, value);
   else
       //null，创建ThreadLocalMap对象，将[t, value]加入map，并赋值给当前线程的localThreads字段
       createMap(t, value);
}

remove()方法

remove()方法的源码，具体代码的解释请看注释

public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
          //从当前线程的threadLocals字段中移除当前ThreadLocal对象为键的键值对
          //remove方法在 ThreadLocalMap中实现
          m.remove(this);
     }

从上面的实现代码看，get()、set()、remove这三个方法都是很简单的从一个ThreadLocalMap中获取设置或者移除值，那么有一个核心就是ThreadLocalMap，那么下面就分析下ThreadLocalMap类

ThreadLocalMap的实现

---

个人觉得replaceStaleEntry()、expungeStaleEntry()、cleanSomeSlots()这三个方法是ThreadLocal中非常重要难以理解的方法；

/**
 * ThreadLocalMap 是一个定制的哈希散列映射，仅仅用用来维护线程本地变量
 * 对其的所有操作都在ThreadLocal类里面。
 * 使用软引用作为这个哈希表的key值（软引用引用的对象在强引用解除引用后的下一次GC会被释放）
 * 由于不使用引用队列，表里的数据只有在表空间不足时才会被释放
 * （因为使用的时key-value，在key被释放·null·后这个表对应的位置不会变为null，需要手动释放）
 *  这个map和HashMap不同的地方是，
 *  在发生哈希冲突的时候HashMap会使用链表（jdk8之后也可能是红黑树）存储（拉链法）
 *  而这里使用的是向后索引为null的表项来存储（开放地址法）
 */
static class ThreadLocalMap {

    /**
     * 这个hash Map的条目继承了 WeakReference, 使用他的ref字段作为key（一个ThreadLocal对象）
     * ThreadLocal object).  注意当键值为null时代表整个键已经不再被引用（ThreadLocal
     * 对象已经被垃圾回收）因此可以删除对应的条目
     */
    static class Entry extends WeakReference> {
        /** The value associated with this ThreadLocal. */
        Object value;

        Entry(ThreadLocal k, Object v) {
            //key值是当前TreadLocal对象的弱引用
            super(k);
            value = v;
        }
    }

    //类的属性字段，基本和HashMap作用一致
    
    //初始容量，必须是2的幂
    private static final int INITIAL_CAPACITY = 16;

    //哈希表 
    //长度必须是2的幂，必要时会调整大小
    private Entry[] table;

    //表中存储数据的个数
    private int size = 0;

    //当表中数据的个数达到这个值时需要扩容
    private int threshold; // Default to 0

    //设置threshold ，负载系数时2/3，也就是说当前表中数据的条目
    //达到表总容量的2/3就需要扩容
    private void setThreshold(int len) {
        threshold = len * 2 / 3;
    }

    /**
     * Increment i modulo len.
     */
    //这个注释不明白，但是在代码实现中遍历表的的时候用来判断是否到了表的结尾
    //如果到了表节位就从表首接着这遍历
    private static int nextIndex(int i, int len) {
        return ((i + 1 < len) ? i + 1 : 0);
    }

    /**
     * Decrement i modulo len.
     */
    //这个注释不明白，但是在代码实现中遍历表的的时候用来判断是否到了表的头部
    //如果到了表节位就从表尾接着这遍历
    private static int prevIndex(int i, int len) {
        return ((i - 1 >= 0) ? i - 1 : len - 1);
    }

    //构造一个新map包含 (firstKey, firstValue).
    ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
        //构造表
        table = new Entry[INITIAL_CAPACITY];
        //确定需要加入的数据的位置
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        构造一个新的Entry对象并放入到表的对应位置
        table[i] = new Entry(firstKey, firstValue);
        //设置当前表中的数据个数
        size = 1;
        // 设置需要扩容的临界点
        setThreshold(INITIAL_CAPACITY);
    }

    //这个方法在创建一个新线程调用到Thread.init()方法是会被调用
    //目的是将父线程的inheritableThreadLocals传递给子线程
    //创建的map会被存储在Thread.inheritableThreadLocals中
    //根据parentMap构造一个新的ThreadLocalMap，
    //这个map包含了所有parentMap的值
    //只有在createInheritedMap调用
    private ThreadLocalMap(ThreadLocalMap parentMap) {
        Entry[] parentTable = parentMap.table;
        int len = parentTable.length;
        setThreshold(len);
        //根据parentMap的长度（容量）构造table
        table = new Entry[len];

        //依次复制parentMap中的数据
        for (int j = 0; j < len; j++) {
            Entry e = parentTable[j];
            if (e != null) {
                @SuppressWarnings("unchecked")
                ThreadLocal