方法

set()

获取当前线程 根据线程从map中获取 value 如果换取不到则创建一个map key是当前线程 valua 是set的值
根据hashcode 找下标 然后拿到下标 从i 开始进行遍历进行线性探索 找如果当前下标已经有值了 则进行替换 如果没有值的话则添加

get()

remove()

withInitial()

原理

Dingtalk_20220420175428.jpg

线性探索

用来解决hash冲突的一种策略 是一种开放寻址的策略
通过hash 函数把key映射到hash 表中的一个位置来访问记录 从而加快查找的速度 存放记录的数据就是hash表(散列表)
当我们针对一个key通过hash函数计算产生一个位置 而这个位置在hash表中已经被另外一个键值对占比时 线性探索就可以解决这种情况
写入:查找hash表中冲突单元最近的空闲单元 把新的键值插入这个空闲单元
查找:从根据 hash函数计算得到的位置开始往后查找 直到找到与key对应的value或找到空的单元
就是个map key是指向当前 ThreadLocal实例的弱引用 value就是数据

ThreadLocalMap中的弱引用

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

set（）

  1.    public void set(T value) {
  2.         //拿到当前线程
  3.         Thread t = Thread.currentThread();
  4.         //根据当前线程找当前线程的 ThreadLocalMap
  5.         ThreadLocalMap map = getMap(t);
  6.         //不等于空 直接set
  7.         if (map != null) key ThreadLocal的弱引用的实例
  8.             map.set(this, value);
  9.         else
  10.             //直接创建
  11.             createMap(t, value);
  12.     }
  1.    //t是当前线程 t.threadLocals   表示当前线程的ThreadLocalMap    
  2.    // ThreadLocalMap   的key 是this 表示当前对象 当前对象是 ThreadLocal      value 是输入的值
  3.     void createMap(Thread t, T firstValue) {
  4.         t.threadLocals = new ThreadLocalMap(this, firstValue);
  5.     }
  1.   private void set(ThreadLocal<?> key, Object value) {
  3.             // We don't use a fast path as with get() because it is at
  4.             // least as common to use set() to create new entries as
  5.             // it is to replace existing ones, in which case, a fast
  6.             // path would fail more often than not.
  8.             Entry[] tab = table;
  9.             int len = tab.length;
  10.             //根据hash code找数组的下标
  11.             int i = key.threadLocalHashCode & (len-1);
  13.             //从i开始遍历 直到最后一个 线性探索
  14.             for (Entry e = tab[i];
  15.                  e != null;
  16.                  e = tab[i = nextIndex(i, len)]) {
  17.                 ThreadLocal<?> k = e.get();
  18.                  //如果key相等则覆盖
  19.                 if (k == key) {
  20.                     e.value = value;
  21.                     return;
  22.                 }
  23.                 //如果key 为null 用新key  value覆盖
  24.                 if (k == null) {
  25.                     //覆盖 并清理 key== null的数据
  26.                     replaceStaleEntry(key, value, i);
  27.                     return;
  28.                 }
  29.             }
  31.             tab[i] = new Entry(key, value);
  32.             int sz = ++size;
  33.             //超过阈值不需要扩容  
  34.             if (!cleanSomeSlots(i, sz) && sz >= threshold)
  35.                 rehash();
  36.         }

向前查找失效的entry向后查找可以被覆盖的entry
向前查找有失效的enrty 向后未找到可以覆盖的Entry
向前未查找到失效的entry 向后找到可以覆盖的Entry
向前未查找到失效的enrty 向后未查找到失效的entry

  1.  private void replaceStaleEntry(ThreadLocal<?> key, Object value,
  2.                                        int staleSlot) {
  3.             Entry[] tab = table;
  4.             int len = tab.length;
  5.             Entry e;
  7.             // Back up to check for prior stale entry in current run.
  8.             // We clean out whole runs at a time to avoid continual
  9.             // incremental rehashing due to garbage collector freeing
  10.             // up refs in bunches (i.e., whenever the collector runs).
  11.             //向前扫描 查找最前面无效的key 
  12.             int slotToExpunge = staleSlot;
  13.             for (int i = prevIndex(staleSlot, len);
  14.                  (e = tab[i]) != null;
  15.                  i = prevIndex(i, len))
  16.                 if (e.get() == null)
  17.                     //循环遍历 定位最前面无效的key
  18.                     slotToExpunge = i;
  20.             // Find either the key or trailing null slot of run, whichever
  21.             // occurs first
  22.             //从i开始向后查找 遍历数组的最后一个Entry
  23.             for (int i = nextIndex(staleSlot, len);
  24.                  (e = tab[i]) != null;
  25.                  i = nextIndex(i, len)) {
  26.                 ThreadLocal<?> k = e.get();
  28.                 // If we find key, then we need to swap it
  29.                 // with the stale entry to maintain hash table order.
  30.                 // The newly stale slot, or any other stale slot
  31.                 // encountered above it, can then be sent to expungeStaleEntry
  32.                 // to remove or rehash all of the other entries in run.
  33.                 //找到匹配的key之后
  34.                 if (k == key) {
  35.                     e.value = value;
  36.                     //更新 value值
  37.                     tab[i] = tab[staleSlot];
  38.                     tab[staleSlot] = e;
  40.                     // Start expunge at preceding stale entry if it exists
  41.                     //如果最前面无效的key 和当前的key相同 责任将 i作为起点开始清理
  42.                     if (slotToExpunge == staleSlot)
  43.                         slotToExpunge = i;
  44.                     //清理
  45.                     cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
  46.                     return;
  47.                 }
  49.                 // If we didn't find stale entry on backward scan, the
  50.                 // first stale entry seen while scanning for key is the
  51.                 // first still present in the run.
  52.                 //如果当前的slot已经无效 并且在向前扫描的过程中没有无效的slot 则更新slotToExpunge当前位置
  53.                 if (k == null && slotToExpunge == staleSlot)
  54.                     slotToExpunge = i;
  55.             }
  57.             // If key not found, put new entry in stale slot
  58.             tab[staleSlot].value = null;
  59.             //如果key对应的value不存在 则直接放一个新的Entry
  60.             tab[staleSlot] = new Entry(key, value);
  62.             // If there are any other stale entries in run, expunge them
  63.             //如果有任何无效的slot 则做一次清理 
  64.             if (slotToExpunge != staleSlot)
  65.                 cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
  66.         }

get()

  1.     public T get() {
  2.         Thread t = Thread.currentThread();
  3.         //根据当前线程拿到一个 ThreadLocalMap
  4.         ThreadLocalMap map = getMap(t);
  5.         if (map != null) {
  6.             //根据当前的ThreadLocal实例的软引用 拿value
  7.             ThreadLocalMap.Entry e = map.getEntry(this);
  8.             if (e != null) {
  9.                 @SuppressWarnings("unchecked")
  10.                 T result = (T)e.value;
  11.                 return result;
  12.             }
  13.         }
  14.         return setInitialValue();
  15.     }
  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.     }

ThreadLocal内存泄漏

ThreadLocal每个线程用完后 都需要调用 remove（）方法防止内存泄漏