创建一个 ThreadLocal 变量，那么访问这个变量的每个线程都会有这个变量的一个本地副本。
多线程操作该变量时，实际操作的是自己的副本。

Thread 类中有 threadLocals 和 inheritableThreadLocals，都是 ThreadLocalMap 类型的变量。
默认情况下，每个线程中这两个变量都为 null，当线程第一次调用 ThreadLocal 的 set 或 get 方法才会创建它们。

每个线程的本地变量不是存放在 ThreadLocal 实例里面，而是存放在调用线程的 threadLocals 变量里面。
也就是说，ThreadLocal 类型的本地变量存放在具体的线程内存空间中。

Thread 里面的 threadLocals 为何为 map 结构？
因为每个线程可以关联多个 ThreadLocal 变量

ThreadLocal

  1. package java.lang;
  2. import java.lang.ref.*;
  3. import java.util.Objects;
  4. import java.util.concurrent.atomic.AtomicInteger;
  5. import java.util.function.Supplier;
  7. public class ThreadLocal<T> {
  8.     /**ThreadLocal 通过常量 threadLocalHashCode 来标识每一个 ThreadLocal 的唯一性
  9.      */
  10.     private final int threadLocalHashCode = nextHashCode();
  12.     /**
  13.      * 下一个 hash code 通过 AtomicInteger 的CAS 操作 保证原子性 初始值为0
  14.      */
  15.     private static AtomicInteger nextHashCode =
  16.         new AtomicInteger();
  18.     /**
  19.      * Hash增量 ，它可以使hashcode均匀的分布在大小为2的N次方的数组里
  20.      */
  21.     private static final int HASH_INCREMENT = 0x61c88647;
  23.     /**(初始值为0)的基础上每次累加0x61c88647*/
  24.     private static int nextHashCode() {
  25.         return nextHashCode.getAndAdd(HASH_INCREMENT);
  26.     }
  28.     protected T initialValue() {
  29.         return null;
  30.     }
  32.     /**
  33.      * 支持Lambda表达式，和ThreadLocal重写的initialValue()效果一样。
  34.      * ThreadLocal<Integer> seqNum = ThreadLocal.withInitial(() -> 0);
  35.      * @since 1.8
  36.      */
  37.     public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
  38.         return new SuppliedThreadLocal<>(supplier);
  39.     }
  41.     public ThreadLocal() {
  42.     }
  44.     /**
  45.      * 获取当前线程存的值，如果没有则拷贝
  46.      */
  47.     public T get() {
  48.         Thread t = Thread.currentThread();
  49.         // 获取当前线程的 threadLocals 变量
  50.         ThreadLocalMap map = getMap(t);
  51.         if (map != null) {
  52.             // 如果线程 threadLocals 有值，则获取 以当前实例对象为key的 value
  53.             ThreadLocalMap.Entry e = map.getEntry(this);
  54.             // 如果可以找到，则直接返回该 value
  55.             if (e != null) {
  56.                 @SuppressWarnings("unchecked")
  57.                 T result = (T)e.value;
  58.                 return result;
  59.             }
  60.         }
  61.         // 找不到就初始化，并返回初始化的值
  62.         return setInitialValue();
  63.     }
  65.     /**
  66.      * setInitialValue()调用重写的initialValue()返回新值（如果没有重写initialValue将返回          * 默认值null），
  67.      * 并将新值存入当前线程的ThreadLocalMap（如果当前线程没有ThreadLocalMap，会先创建一个）
  68.      */
  69.     private T setInitialValue() {
  70.         T value = initialValue();
  71.         Thread t = Thread.currentThread();
  72.         ThreadLocalMap map = getMap(t);
  73.         if (map != null)
  74.             map.set(this, value);
  75.         else
  76.             createMap(t, value);
  77.         return value;
  78.     }
  80.     public void set(T value) {
  81.         // 获取当前线程
  82.         Thread t = Thread.currentThread();
  83.         // 将当前线程作为 key，去查找对应的线程变量，找到则设置值
  84.         ThreadLocalMap map = getMap(t);
  85.         if (map != null)
  86.             map.set(this, value);
  87.         else
  88.             // 如果是第一次调，创建线程对应的的 HashMap
  89.             createMap(t, value);
  90.     }
  92.     public void remove() {
  93.          // 获取当前线程的ThreadLocalMap
  94.          ThreadLocalMap m = getMap(Thread.currentThread());
  95.          // map不为空，则移除当前ThreadLocal作为key的键值对。
  96.          if (m != null)
  97.              m.remove(this);
  98.      }
  100.     ThreadLocalMap getMap(Thread t) {
  101.         // 获取线程自己的 threadLocals
  102.         return t.threadLocals;
  103.     }
  105.     void createMap(Thread t, T firstValue) {
  106.         // 创建线程自己的 threadLocals
  107.         // threadLocals 的类型就是下面的 ThreadLocalMap 
  108.         // key 就是当前 ThreadLocal 的实例对象引用，value 就是 set 的值
  109.         t.threadLocals = new ThreadLocalMap(this, firstValue);
  110.     }
  112.     /**
  113.      * 在子线程创建的时候会去拷一份父线程的inheritableThreadLocals
  114.      */
  115.     static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
  116.         return new ThreadLocalMap(parentMap);
  117.     }
  119.     /**
  120.      * 方法childValue在子类InheritableThreadLocal中定义
  121.      */
  122.     T childValue(T parentValue) {
  123.         throw new UnsupportedOperationException();
  124.     }
  126.     /**
  127.      * withInitial 返回的
  128.      */
  129.     static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {
  131.         private final Supplier<? extends T> supplier;
  133.         SuppliedThreadLocal(Supplier<? extends T> supplier) {
  134.             this.supplier = Objects.requireNonNull(supplier);
  135.         }
  137.         @Override
  138.         protected T initialValue() {
  139.             return supplier.get();
  140.         }
  141.     }
  143.     /**
  144.      * 线程放 threadLocal 对象的值的容器
  145.      */
  146.     static class ThreadLocalMap {
  148.         /**
  149.          *  之所以用弱引用，是为了解决线程与ThreadLocal之间的强绑定关系
  150.          * 会导致如果线程没有被回收，则GC便一直无法回收这部分内容
  151.          */
  152.         static class Entry extends WeakReference<ThreadLocal<?>> {
  153.             /** The value associated with this ThreadLocal. */
  154.             Object value;
  156.             Entry(ThreadLocal<?> k, Object v) {
  157.                 super(k);
  158.                 value = v;
  159.             }
  160.         }
  162.         /**
  163.          * 初始容量，必须 2 的 n 次方，为了减少碰撞，能够让保存的元素尽量的分散
  164.          */
  165.         private static final int INITIAL_CAPACITY = 16;
  167.         /**
  168.          * 数组容器，容量为 2 的 n 次方
  169.          */
  170.         private Entry[] table;
  172.         /**
  173.          * 当前存放的 ThreadLocal 元素数量
  174.          */
  175.         private int size = 0;
  177.         /**
  178.          * 下一次扩容的阀值
  179.          */
  180.         private int threshold; // Default to 0
  182.         /**
  183.          * 设置下一次阀值为当前的 二分之三
  184.          */
  185.         private void setThreshold(int len) {
  186.             threshold = len * 2 / 3;
  187.         }
  189.         /**
  190.          * 获取下一个索引，超出长度则返回0，所以 entry数组实际上是一个环形结构
  191.          */
  192.         private static int nextIndex(int i, int len) {
  193.             return ((i + 1 < len) ? i + 1 : 0);
  194.         }
  196.         /**
  197.          * 返回上一个索引，如果-1为负数，返回长度-1的索引
  198.          */
  199.         private static int prevIndex(int i, int len) {
  200.             return ((i - 1 >= 0) ? i - 1 : len - 1);
  201.         }
  203.         /**
  204.          * 构造函数，ThreadLocal为key，泛型为value
  205.          */
  206.         ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
  207.             // // 初始化table的大小为16
  208.             table = new Entry[INITIAL_CAPACITY];
  209.             // 通过hashcode & （长度-1）的位运算，确定键值对的位置
  210.             int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
  211.             // 创建一个新节点保存在table当中
  212.             table[i] = new Entry(firstKey, firstValue);
  213.             // 存放元素数量为 1
  214.             size = 1;
  215.             // 更新下次扩容阀值
  216.             setThreshold(INITIAL_CAPACITY);
  217.         }
  219.         /**
  220.          * 构造函数，传入 父线程的 threadLocals 对象
  221.          * 这是InheritableThreadLocal提供了了一种父子间数据共享的机制
  222.          */
  223.         private ThreadLocalMap(ThreadLocalMap parentMap) {
  224.             Entry[] parentTable = parentMap.table;
  225.             int len = parentTable.length;
  226.             setThreshold(len);
  227.             table = new Entry[len];
  229.             for (int j = 0; j < len; j++) {
  230.                 Entry e = parentTable[j];
  231.                 if (e != null) {
  232.                     @SuppressWarnings("unchecked")
  233.                     ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
  234.                     if (key != null) {
  235.                         Object value = key.childValue(e.value);
  236.                         Entry c = new Entry(key, value);
  237.                         int h = key.threadLocalHashCode & (len - 1);
  238.                         while (table[h] != null)
  239.                             h = nextIndex(h, len);
  240.                         table[h] = c;
  241.                         size++;
  242.                     }
  243.                 }
  244.             }
  245.         }
  247.         /**
  248.          * 获取指定 ThreadLocal 的索引位置，通过下标索引获取内容
  249.          */
  250.         private Entry getEntry(ThreadLocal<?> key) {
  251.             // 计算下标
  252.             int i = key.threadLocalHashCode & (table.length - 1);
  253.             Entry e = table[i];
  254.             if (e != null && e.get() == key)
  255.                 return e;
  256.             else
  257.                 // 线性探测法, 找不到的话接着从i位置开始向后遍历
  258.                 return getEntryAfterMiss(key, i, e);
  259.         }
  261.         /**
  262.          * 线性探测
  263.          */
  264.         private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
  265.             Entry[] tab = table;
  266.             int len = tab.length;
  267.             // 循环向后遍历，直到找到了其他不相等的 key 停止，返回 null
  268.             while (e != null) {
  269.                 // 获取节点对应的 key
  270.                 ThreadLocal<?> k = e.get();
  271.                 // 相等就是找到了，返回
  272.                 if (k == key)
  273.                     return e;
  274.                 // 如果为null，触发一次连续段清理
  275.                 if (k == null)
  276.                     expungeStaleEntry(i);
  277.                 else
  278.                     // 获取下一个下标接着进行判断
  279.                     i = nextIndex(i, len);
  280.                 e = tab[i];
  281.             }
  282.             return null;
  283.         }
  285.         /**通过这个方法，我们可以看出该哈希表是用线性探测法来解决冲突的*/
  286.         private void set(ThreadLocal<?> key, Object value) {
  287.             // 新开一个引用指向table
  288.             Entry[] tab = table;
  289.             // 获取table的长度
  290.             int len = tab.length;
  291.             // 获取对应ThreadLocal在table当中的下标
  292.             int i = key.threadLocalHashCode & (len-1);
  293.             /**
  294.              * 从该下标开始循环遍历
  295.              * 1、如遇相同key，则直接替换value
  296.              * 2、如果该key已经被回收失效，则替换该失效的key
  297.              */
  298.             for (Entry e = tab[i];
  299.                  e != null;
  300.                  e = tab[i = nextIndex(i, len)]) {
  301.                 ThreadLocal<?> k = e.get();
  303.                 if (k == key) {
  304.                     e.value = value;
  305.                     return;
  306.                 }
  307.                 // 如果 k 为 null，则替换当前失效的k所在Entry节点
  308.                 if (k == null) {
  309.                     replaceStaleEntry(key, value, i);
  310.                     return;
  311.                 }
  312.             }
  313.             // 找到空的位置，创建Entry对象并插入
  314.             tab[i] = new Entry(key, value);
  315.             int sz = ++size;
  316.             // 如果到达扩容阀值，执行扩容
  317.             if (!cleanSomeSlots(i, sz) && sz >= threshold)
  318.                 rehash();
  319.         }
  321.         /**
  322.          * Remove the entry for key.
  323.          */
  324.         private void remove(ThreadLocal<?> key) {
  325.             Entry[] tab = table;
  326.             int len = tab.length;
  327.             int i = key.threadLocalHashCode & (len-1);
  328.             for (Entry e = tab[i];
  329.                  e != null;
  330.                  e = tab[i = nextIndex(i, len)]) {
  331.                 if (e.get() == key) {
  332.                     e.clear();
  333.                     expungeStaleEntry(i);
  334.                     return;
  335.                 }
  336.             }
  337.         }
  339.         private void replaceStaleEntry(ThreadLocal<?> key, Object value,
  340.                                        int staleSlot) {
  341.             // 新开一个引用指向table
  342.             Entry[] tab = table;
  343.             int len = tab.length;
  344.             Entry e;
  346.             // 记录当前失效的节点下标
  347.             int slotToExpunge = staleSlot;
  348.             /**
  349.              * 通过这个for循环的prevIndex(staleSlot, len)可以看出
  350.              * 这是由staleSlot下标开始向前扫描
  351.              * 查找并记录最前位置value为null的下标
  352.              */
  353.             for (int i = prevIndex(staleSlot, len);
  354.                  (e = tab[i]) != null;
  355.                  i = prevIndex(i, len))
  356.                 if (e.get() == null)
  357.                     slotToExpunge = i;
  359.             /**
  360.              * 通过for循环nextIndex(staleSlot, len)可以看出
  361.              * 这是由staleSlot下标开始向后扫描
  362.              */
  363.             for (int i = nextIndex(staleSlot, len);
  364.                  (e = tab[i]) != null;
  365.                  i = nextIndex(i, len)) {
  366.                 // 获取Entry节点对应的ThreadLocal对象
  367.                 ThreadLocal<?> k = e.get();
  369.                 /**
  370.                  * 如果与新的key对应，直接赋值value
  371.                  * 则直接替换i与staleSlot两个下标
  372.                  */
  373.                 if (k == key) {
  374.                     e.value = value;
  376.                     tab[i] = tab[staleSlot];
  377.                     tab[staleSlot] = e;
  379.                     // Start expunge at preceding stale entry if it exists
  380.                     if (slotToExpunge == staleSlot)
  381.                         slotToExpunge = i;
  382.                     cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
  383.                     return;
  384.                 }
  386.                 // i之前的节点里，没有value为null的情况
  387.                 if (k == null && slotToExpunge == staleSlot)
  388.                     slotToExpunge = i;
  389.             }
  391.             // If key not found, put new entry in stale slot
  392.             tab[staleSlot].value = null;
  393.             tab[staleSlot] = new Entry(key, value);
  395.             if (slotToExpunge != staleSlot)
  396.                 cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
  397.         }
  399.         /**
  400.          * 使用的是弱引用，那便有可能在GC的时候就被回收了。所以需要清理
  401.          * 如果有很多Entry节点已经被回收了，但是在table数组中还留着位置，不清理就会浪费资源
  402.          * 在清理节点的同时，可以将后续非空的Entry节点重新计算下标进行排放，get的时候就能快速定位资源，加快效率。
  403.          */
  404.         private int expungeStaleEntry(int staleSlot) {
  405.             // 新的引用指向table
  406.             Entry[] tab = table;
  407.             // 获取长度
  408.             int len = tab.length;
  410.             // 先将传过来的下标位置 设置为null
  411.             tab[staleSlot].value = null;
  412.             tab[staleSlot] = null;
  413.             // 更新当前元素个数 --
  414.             size--;
  416.             // 遍历删除指定节点所有后续节点当中，ThreadLocal被回收的节点
  417.             Entry e;
  418.             int i;
  419.             for (i = nextIndex(staleSlot, len);
  420.                  (e = tab[i]) != null;
  421.                  i = nextIndex(i, len)) {
  422.                 // 获取entry当中的key
  423.                 ThreadLocal<?> k = e.get();
  424.                 // 如果ThreadLocal为null，则将value以及数组下标所在位置设置null，方便GC
  425.                 if (k == null) {
  426.                     e.value = null;
  427.                     tab[i] = null;
  428.                     size--;
  429.                 } else {
  430.                     // 如果后续节点不为空 重新计算key的下标
  431.                     int h = k.threadLocalHashCode & (len - 1);
  432.                     // 如果位置不变，则下一个
  433.                     // 如果位置变了，当前位置设为 null，根据线性探测把 e 设置到新位置
  434.                     if (h != i) {
  435.                         tab[i] = null;
  436.                         while (tab[h] != null)
  437.                             h = nextIndex(h, len);
  438.                         tab[h] = e;
  439.                     }
  440.                 }
  441.             }
  442.             return i;
  443.         }
  445.         private boolean cleanSomeSlots(int i, int n) {
  446.             boolean removed = false;
  447.             Entry[] tab = table;
  448.             int len = tab.length;
  449.             do {
  450.                 i = nextIndex(i, len);
  451.                 Entry e = tab[i];
  452.                 if (e != null && e.get() == null) {
  453.                     n = len;
  454.                     removed = true;
  455.                     i = expungeStaleEntry(i);
  456.                 }
  457.             } while ( (n >>>= 1) != 0);
  458.             return removed;
  459.         }
  461.         /**
  462.         *重新包装和/或调整桌子的尺寸。首先扫描整个系统
  463.         *表删除过时的条目。如果这还不够
  464.         *缩小表的大小，将表的大小增加一倍。
  465.         */
  466.         private void rehash() {
  467.             expungeStaleEntries();
  469.             // Use lower threshold for doubling to avoid hysteresis
  470.             if (size >= threshold - threshold / 4)
  471.                 resize();
  472.         }
  474.         /**
  475.          * 把容量增加一倍。
  476.          */
  477.         private void resize() {
  478.             Entry[] oldTab = table;
  479.             int oldLen = oldTab.length;
  480.             int newLen = oldLen * 2;
  481.             Entry[] newTab = new Entry[newLen];
  482.             int count = 0;
  484.             for (int j = 0; j < oldLen; ++j) {
  485.                 Entry e = oldTab[j];
  486.                 if (e != null) {
  487.                     ThreadLocal<?> k = e.get();
  488.                     if (k == null) {
  489.                         e.value = null; // Help the GC
  490.                     } else {
  491.                         int h = k.threadLocalHashCode & (newLen - 1);
  492.                         while (newTab[h] != null)
  493.                             h = nextIndex(h, newLen);
  494.                         newTab[h] = e;
  495.                         count++;
  496.                     }
  497.                 }
  498.             }
  500.             setThreshold(newLen);
  501.             size = count;
  502.             table = newTab;
  503.         }
  505.         /**
  506.          * 删除表中所有过时的条目。
  507.          */
  508.         private void expungeStaleEntries() {
  509.             Entry[] tab = table;
  510.             int len = tab.length;
  511.             for (int j = 0; j < len; j++) {
  512.                 Entry e = tab[j];
  513.                 if (e != null && e.get() == null)
  514.                     expungeStaleEntry(j);
  515.             }
  516.         }
  517.     }
  518. }

InheritableThreadLocal

�让子线程可以访问在父线程中设置的本地变量。

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    /**
     * 在子线程复制父线程值时调用，子类可以重写该方法，处理子线程复制的初始值
     */
    protected T childValue(T parentValue) {
        return parentValue;
    }

    /**
     *  get也变成了 获取 inheritableThreadLocals
     */
    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }

    /**
     * 第一次 set 时创建的是 inheritableThreadLocals，而不是 threadLocals 了
     */
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

什么情况下需要子线程获取父线程的 threadLocal 变量呢？
比如子线程需要使用存放在 threadLocal 变量中的用户登录信息，
比如中间件需要把同一的 id 追踪的整个调用链路记录下来。

子线程使用父线程的 threadLocal 方法有多种，比如创建线程时传入父线程中的变量，将其复制到子线程。但这都改变了使用习惯。