ThreadLocal 是线程本地变量，不是线程。

总结与使用

ThreadLocal 如何生效？ 实际是Thread中会保存一个ThreadLocalMap ，ThreadLocal 操作都是对当前线程中的ThreadLoacalMap进行操作。

如何使用？
对多线程重复创建对象（对象线程不安全，所有每个线程需要有单独的样本），
如线程池中有10个线程，每一次执行都创建一个SimpleDateFormat（线程不安全，所以每个线程都需要一个新的对象）， 线程运行1000次，那么就需要创建1000次SimpleDateFormat对象，而实际每个线程拥有一个对象就不需要再重复创建，也就利用ThreadLocal，将SimpleDateFormat对象保留到线程本地，只需要创建10个对象即可。
Spring JdbcConnection 实现，线程中保留Connetction在本地，能防止connection被其他线程中断，也不需要每个线程创建都建立connection连接。
注意事项：
由于数据保留在线程ThreadLocalMap中，所有如果不清理，会是线程数据不断累增，或者是脏数据带入了下一次线程运行。

1.extends 和 implement

无继承与实现

2.构造方法

空构造

  1. public ThreadLocal() {}

3.属性

threadLocalHashCode: ThreadLocal自定义的HashCode

nextHashCode: AtomicInteger 原子操作，HashCode增长

  1.  private final int threadLocalHashCode = nextHashCode();
  2. private static AtomicInteger nextHashCode = new AtomicInteger();

4.方法

nextHashCode()

获取ThreadLocal对象的hashCode值

  1.     private static int nextHashCode() {
  2.         return nextHashCode.getAndAdd(HASH_INCREMENT);
  3.     }

initialValue(): ThreadLocal 初始化方法，返回一个null值

  1.  protected T initialValue() {return null; }

withInitial(): 创建线程本地变量，放回的SuppliedThreadLocal重写了initialValue方法，会根据提供的supplier方法来生成初始值

  1.     public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
  2.         return new SuppliedThreadLocal<>(supplier);
  3.     }

get(): 返回当前线程副本的值，如果没有值，就设置并返回初始化值。

  1.     public T get() {
  2.         Thread t = Thread.currentThread();
  3.         //获取线程本地变量对象
  4.         ThreadLocalMap map = getMap(t);
  5.         if (map != null) {
  6.             ThreadLocalMap.Entry e = map.getEntry(this);
  7.             if (e != null) {
  8.                 @SuppressWarnings("unchecked")
  9.                 T result = (T)e.value;
  10.                 return result;
  11.             }
  12.         }
  13.         return setInitialValue();
  14.     }

getMap(Thread t)：获取线程中的ThreadLocalMap（线程本地变量集合）对象值

  1. ThreadLocalMap getMap(Thread t) {
  2.     //返回线程类中的ThreadLocal 值
  3.     return t.threadLocals;
  4. }

setInitialValue()：设置初始化值

  1.     private T setInitialValue() {
  2.         T value = initialValue();
  3.         Thread t = Thread.currentThread();
  4.         ThreadLocalMap map = getMap(t);
  5.         if (map != null)
  6.             map.set(this, value);
  7.         else
  8.             createMap(t, value);
  9.         return value;
  10.     }

set(T value)： 设置变量值

  1. public void set(T value) {
  2.     Thread t = Thread.currentThread();
  3.     ThreadLocalMap map = getMap(t);
  4.     if (map != null)
  5.         map.set(this, value);
  6.     else
  7.         createMap(t, value);
  8. }

remove(): 移除变量值

  1. public void remove() {
  2.     ThreadLocalMap m = getMap(Thread.currentThread());
  3.     if (m != null)
  4.         m.remove(this);
  5. }

createMap(Thread t, T value): 如果线程本地变量集合为null 那么创建一个线程本地变量集合

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

createInheritedMap(ThreadLocalMap ): 这个方法提供给线程类使用，为了让线程能继承父线程的本地变量。

详细可查看线程类的init方法：Thread.init() 代码第45行

  1.     static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
  2.         return new ThreadLocalMap(parentMap);
  3.     }

childValue(T parentValue):

InheritableThreadLocal 类重写了此方法，返回 parentValue

  1.     T childValue(T parentValue) {
  2.         throw new UnsupportedOperationException();
  3.     }

5.内部类

静态内部类

ThreadLocalMap: 存储结构类

  1. static class ThreadLocalMap {
  2.         //ThreadLocal 作为弱引用键,如果ThreadLocal =null，也就意味着不在引用该键
  3.         static class Entry extends WeakReference<ThreadLocal<?>> {         
  4.             Object value;
  5.             Entry(ThreadLocal<?> k, Object v) {
  6.                 super(k);
  7.                 value = v;
  8.             }
  9.         }
  10.         //初始化大小，必须是2的幂  为什么？ 计算Entry数组下标时用，见 TheadLocalMap(ThreadLocal<?> firstKey, Object firstValue)方法
  11.         private static final int INITIAL_CAPACITY = 16;
  12.         //数据存储 table.length 必须是2的幂
  13.         private Entry[] table;
  14.         //table的大小
  15.         private int size = 0;
  16.         //下一次扩容的大小 长度的 0.5
  17.         private int threshold; 
  19.         private void setThreshold(int len) {
  20.             threshold = len * 2 / 3;
  21.         }
  22.         //数组的下一个位置索引，超过长度回到初始位置
  23.         private static int nextIndex(int i, int len) {
  24.             return ((i + 1 < len) ? i + 1 : 0);
  25.         }
  26.         //数组的前一个位置索引
  27.         private static int prevIndex(int i, int len) {
  28.             return ((i - 1 >= 0) ? i - 1 : len - 1);
  29.         }
  30.         //构造方法
  31.         ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
  32.             //初始化数组大小
  33.             table = new Entry[INITIAL_CAPACITY];
  34.             //下标是hashCode 与上 (INITIAL_CAACITY -1)  2的幂是 100000...  ， 10000.... -1 = 11111......
  35.             int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
  36.             //设置初始值
  37.             table[i] = new Entry(firstKey, firstValue);
  38.             size = 1;
  39.             //设置下一次扩容的大小
  40.             setThreshold(INITIAL_CAPACITY);
  41.         }
  42.         //私有构造 复制一个新的ThreadLocalMap ，唯一调用的方法为 createInheritedMap(ThreadLocalMap parentMap);
  43.         private ThreadLocalMap(ThreadLocalMap parentMap) {
  44.             Entry[] parentTable = parentMap.table;
  45.             int len = parentTable.length;
  46.             setThreshold(len);
  47.             table = new Entry[len];
  48.             for (int j = 0; j < len; j++) {
  49.                 Entry e = parentTable[j];
  50.                 if (e != null) {
  51.                     @SuppressWarnings("unchecked")
  52.                     ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
  53.                     if (key != null) {
  54.                         Object value = key.childValue(e.value);
  55.                         Entry c = new Entry(key, value);
  56.                         int h = key.threadLocalHashCode & (len - 1);
  57.                         while (table[h] != null)
  58.                             h = nextIndex(h, len);
  59.                         table[h] = c;
  60.                         size++;
  61.                     }
  62.                 }
  63.             }
  64.         }
  65.         //查询数组里的对象
  66.         private Entry getEntry(ThreadLocal<?> key) {
  67.             //获取数组下标
  68.             int i = key.threadLocalHashCode & (table.length - 1);
  69.             //如果查询到了，就返回e ，
  70.             //未查询到，调用getEntryAfterMiss，遍历Entry数组进行查询(从位置i开始查询，因为set时，是从下标i向后寻找空位set)
  71.             Entry e = table[i];
  72.             if (e != null && e.get() == key)
  73.                 return e;
  74.             else
  75.                 return getEntryAfterMiss(key, i, e);
  76.         }
  77.         //遍历数组查询
  78.         private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
  79.             Entry[] tab = table;
  80.             int len = tab.length;
  82.             while (e != null) {
  83.                 ThreadLocal<?> k = e.get();
  84.                 if (k == key)
  85.                     return e;
  86.                 if (k == null)
  87.                     //如果key为空，那么删除这个数据，并且重新对数组进行散列计算
  88.                     expungeStaleEntry(i);
  89.                 else
  90.                     i = nextIndex(i, len);
  91.                 e = tab[i];
  92.             }
  93.             return null;
  94.         }
  95.         //set 属性值 1.set值  2.扩容
  96.         private void set(ThreadLocal<?> key, Object value) {
  97.             Entry[] tab = table;
  98.             int len = tab.length;
  99.             int i = key.threadLocalHashCode & (len-1);
  100.             //从下标i开始向后寻址， 直到找到空位，nextIndex是环形循环，到达数组终点时会回到起点继续循环。
  101.             for (Entry e = tab[i];e != null;  e = tab[i = nextIndex(i, len)]) {
  102.                 ThreadLocal<?> k = e.get();
  103.                 if (k == key) {
  104.                     e.value = value;
  105.                     return;
  106.                 }
  107.                 //如果当前位置的key已经不在使用，那么进行替换 （注意，后续位置可能存在Value相同的key，所以replaceStatleEntry还需要遍历后续位置）
  108.                 if (k == null) {
  109.                     replaceStaleEntry(key, value, i);
  110.                     return;
  111.                 }
  112.             }
  113.             tab[i] = new Entry(key, value);
  114.             int sz = ++size;
  115.             if (!cleanSomeSlots(i, sz) && sz >= threshold)
  116.                 rehash();
  117.         }
  119.         private void remove(ThreadLocal<?> key) {
  120.             Entry[] tab = table;
  121.             int len = tab.length;
  122.             int i = key.threadLocalHashCode & (len-1);
  123.             for (Entry e = tab[i];
  124.                  e != null;
  125.                  e = tab[i = nextIndex(i, len)]) {
  126.                 if (e.get() == key) {
  127.                     e.clear();
  128.                     expungeStaleEntry(i);
  129.                     return;
  130.                 }
  131.             }
  132.         }
  133.         //新的Entry 替换已经弃用的Entry 
  134.         private void replaceStaleEntry(ThreadLocal<?> key, Object value,
  135.                                        int staleSlot) {
  136.             Entry[] tab = table;
  137.             int len = tab.length;
  138.             Entry e;
  140.             int slotToExpunge = staleSlot;
  141.             //向上查找 找到其他需要清除 Entry
  142.             //这样 slotToExpunge 代表清除的终点， staleSlot代表清除的起点， 相等时，只清除staleSlot的Entry
  143.             for (int i = prevIndex(staleSlot, len); (e = tab[i]) != null;i = prevIndex(i, len))
  144.                 if (e.get() == null) slotToExpunge = i;
  145.             //遍历Entry数组，看是否能找到与当前ThreadLocalKey相等的对象，如果有，那么进行交换，将Entry交换到staleSlot位置，并替换value
  146.             for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null;i = nextIndex(i, len)) {
  147.                 ThreadLocal<?> k = e.get();
  148.                 if (k == key) {
  149.                     e.value = value;
  150.                     tab[i] = tab[staleSlot];
  151.                     tab[staleSlot] = e;
  152.                     if (slotToExpunge == staleSlot)
  153.                         slotToExpunge = i;
  154.                     //清除数组中弃用的key
  155.                     cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
  156.                     return;
  157.                 }
  158.                 //在处理过程中如果有新的key失效，并且在向上查找时没有找到，那么更换slotToExpunge的位置
  159.                 if (k == null && slotToExpunge == staleSlot)
  160.                     slotToExpunge = i;
  161.             }
  163.             //如果没有在数组中找到与插入TheadLoaclKey相等的，那么直接插入到staleSlot
  164.             tab[staleSlot].value = null;
  165.             tab[staleSlot] = new Entry(key, value);
  166.             //如果需要替换的位置与向上查找时的位置一样，而这个时候staleSlot的位置已经替换了新值，所有就不需要清理数组了
  167.             //如果不一样，那么还是需要清理数组    
  168.             if (slotToExpunge != staleSlot)
  169.                 cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
  170.         }
  171.         //重新散列数组，并且清除弃用的Entry
  172.         private int expungeStaleEntry(int staleSlot) {
  173.             Entry[] tab = table;
  174.             int len = tab.length;
  175.             tab[staleSlot].value = null;
  176.             tab[staleSlot] = null;
  177.             size--;
  178.             Entry e;
  179.             int i;
  180.             //从下标staleSlot开始 向后遍历 直到碰到 数组下标对应的Enrty为空
  181.             for (i = nextIndex(staleSlot, len); (e = tab[i]) != null;i = nextIndex(i, len)) {
  182.                 ThreadLocal<?> k = e.get();
  183.                 //key 为null ，那么清除这个数据，否则就移动到离hash计算的位置最近的空槽处
  185.                 if (k == null) {
  186.                     e.value = null; tab[i] = null; size--;
  187.                 } else {
  188.                     int h = k.threadLocalHashCode & (len - 1);
  189.                     if (h != i) {
  190.                         tab[i] = null;
  191.                         while (tab[h] != null) h = nextIndex(h, len);
  192.                         tab[h] = e;
  193.                     }
  194.                 }
  195.             }
  196.             //这时候 i是 staleSlot 遍历的第一个空槽位置
  197.             return i;
  198.         }
  199.         //清理 n>>>=1 ,表示循环次数为2的幂，也就是len是2的多少次方， 如果len=4 那么循环2次
  200.         private boolean cleanSomeSlots(int i, int n) {
  201.             boolean removed = false;
  202.             Entry[] tab = table;
  203.             int len = tab.length;
  204.             do {
  205.                 i = nextIndex(i, len);
  206.                 Entry e = tab[i];
  207.                 if (e != null && e.get() == null) {
  208.                     //如果找到了新的需要废弃的Entry，那么先清理，然后n重置，继续循环
  209.                     n = len;   removed = true; i = expungeStaleEntry(i);
  210.                 }
  211.             } while ( (n >>>= 1) != 0);
  212.             return removed;
  213.         }
  214.         //清理数组所有弃用的Entry，刷新数组大小，重新hash
  215.         private void rehash() {
  216.             expungeStaleEntries();
  217.             if (size >= threshold - threshold / 4)
  218.                 resize();
  219.         }
  220.         //刷新数组大小，重新hash
  221.         private void resize() {
  222.             Entry[] oldTab = table;
  223.             int oldLen = oldTab.length;
  224.             int newLen = oldLen * 2;
  225.             //扩容
  226.             Entry[] newTab = new Entry[newLen];
  227.             int count = 0;
  228.             //重新hash到新的数组中
  229.             for (int j = 0; j < oldLen; ++j) {
  230.                 Entry e = oldTab[j];
  231.                 if (e != null) {
  232.                     ThreadLocal<?> k = e.get();
  233.                     if (k == null) {
  234.                         e.value = null; // Help the GC
  235.                     } else {
  236.                         int h = k.threadLocalHashCode & (newLen - 1);
  237.                         while (newTab[h] != null)
  238.                             h = nextIndex(h, newLen);
  239.                         newTab[h] = e;
  240.                         count++;
  241.                     }
  242.                 }
  243.             }
  244.             //重置扩容的阈值
  245.             setThreshold(newLen);
  246.             //数组size ，数据的总数
  247.             size = count;
  248.             table = newTab;
  249.         }
  250.         //清除表中所有的弃用Entry
  251.         private void expungeStaleEntries() {
  252.             Entry[] tab = table;
  253.             int len = tab.length;
  254.             for (int j = 0; j < len; j++) {
  255.                 Entry e = tab[j];
  256.                 if (e != null && e.get() == null)
  257.                     expungeStaleEntry(j);
  258.             }
  259.         }
  260.     }

SuppliedThreadLocal：

静态不可被继承类，继承了ThreadLocal类， 重写了initialValue()发放，在调用SuppliedThreadLocal类时，会根据Supplier.get()，拿到初始值。

  1.     static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {
  3.         private final Supplier<? extends T> supplier;
  5.         SuppliedThreadLocal(Supplier<? extends T> supplier) {
  6.             this.supplier = Objects.requireNonNull(supplier);
  7.         }
  9.         @Override
  10.         protected T initialValue() {
  11.             return supplier.get();
  12.         }
  13.     }