看图学源码之——从ThreadLocal 到 TTL 的源码剖析

can_y...

已于 2024-04-03 16:03:34 修改

阅读量737

点赞数 6

分类专栏：看图学源码—JUC 文章标签： java 开发语言

于 2023-11-28 17:48:44 首次发布

本文链接：https://blog.csdn.net/m0_49867458/article/details/134673195

版权

看图学源码—JUC 专栏收录该内容

16 篇文章 3 订阅

订阅专栏

ThreadLocal

定义：

提供线程内部的局部变量，在多线程环境下就可以保证各个线程的变量相互独立于其他线程内的变量，修饰符一般为： private static 类型的，可以关联线程和线程上下文；不同的线程之间不会相互影响。变量只在线程的生命周期内会起作用。可以减少同一个线程内的多个函数或者组件之间一些公共变量传递的复杂性。

特征

特点	内容
线程并发	在多线程并发场景之下
传递数据	可以通过ThreadLocal 在同一个线程，不同组件中传递公共的变量
线程隔离	线程之间的变量是相互独立的，互不影响

对比

synchronized VS. ThreadLocal

	synchronized	ThreadLocal
原理	同步机制采用以时间换空间的方式,只提供了一份变量, 让不同的线程排队访问	ThreadLocal采用以空间换时间的方式, 为每一个线程都提供了一份变量的副本, 从而实现同时访问而互不干扰
侧重点	多个线程之间访问资源的同步	多线程中让每个线程之间的数据相互隔离

下面介绍的 Entry 实际就是键值对 k-v

ThreadLocal内部结构

早期设计

JDK1.8 的版本

每个Thread线程内部都有一个Map(ThreadLocalMap)
每个Map里面存储的是： ThreadLocal对象(key)和线程变量副本(Value)
每个Thread内部的Map是由ThreadLocal维护的, 由ThreadLocal负责向map获取和设置线程变量值
对于不同的线程, 每次获取value的时候别的线程并不能获取当前线程的副本值, 形成了副本的隔离,互不干扰

JDK1.8 的版本的好处：

每个 map 存储的 entry 的数量会变少；因为Threadlocal 数量是小于 Thread 数量的
当 Thread 销毁的时候，ThreadLocalMap 的数量也会随之销毁，会减少内存的使用( 之前以Thread为key会导致ThreadLocalMap的生命周期很长)

ThreadLocal 核心方法的源码

本质上的方法调用的还是 ThreadLocalMap 的方法

构造方法

initialValue()

获取当前线程局部变量的初始值

/**
 * 返回此线程局部变量的当前线程的“初始值”。
 该方法将在线程第一次使用get方法访问变量时被调用，除非该线程之前调用过set方法，在这种情况下，该线程将不会调用initialValue方法。
 通常，每个线程最多调用此方法一次，但如果随后调用remove然后调用get ，则可能会再次调用该方法。
 这个实现只是返回null ；如果程序员希望线程局部变量具有null以外的初始值，则必须对ThreadLocal进行子类化，并重写此方法。
 通常，将使用匿名内部类。
 返回值：该线程局部的初始值
 *
 * @return the initial value for this thread-local
 */
protected T initialValue() {
    return null;
}

总结：

这个方法是一个延迟调用方法，从上面的代码我们得知，在set方法调用之前先调用了get方法时才执行这个初始的方法，并且仅执行1次。
这个方法缺省实现直接返回一个null。
如果想要一个指定的初始值，可以重写此方法。（备注：该方法是一个protected的方法，显然是为了让子类覆盖而设计的)

set()

设置当前线程绑定的局部变量

//将此线程局部变量的当前线程副本设置为指定值。大多数子类不需要重写此方法，仅依靠initialValue方法来设置线程局部变量的值。
//形参： value – 要存储在该线程本地的当前线程副本中的值。
 	public void set(T value) {
    //获取当前线程
        Thread t = Thread.currentThread();
    // 获取此线程对象中维护的 ThreadLocalMap 对象  
        ThreadLocalMap map = getMap(t);
    //  判断是否存在
        if (map != null) {
            map.set(this, value);
        } else {
    // 当前线程 Thread 不存在 ThreadLocalMap 对象. 则调用 createMap 进行 ThreadLocalMap 对象初始化. 并将 t 和 value(对应的值) 作为第一个 entry 存放至 ThreadLocalMap 中
            createMap(t, value);
        }
    }

    /**
     * 获取与 ThreadLocal 关联的映射。在 InheritableThreadLocal 中重写。
     *
     * @param  t the current thread
     * @return the map
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }


    /**
     * 创建与 ThreadLocal 关联的映射。在 InheritableThreadLocal 中重写
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);  // ThreadLocalMap 构造器方法见下面
    }


//Thread类 中的变量
//与该线程相关的 ThreadLocal 值。该映射由 ThreadLocal 类维护。
   ThreadLocal.ThreadLocalMap threadLocals = null;

总结

先去获取当前线程 t ，并由此线程获取其对应的 ThreadLocalMap
要是获取到的map 不是空，就塞到 map 中，K:当前的 ThreadLocal V:value 存储在该线程本地的当前线程副本中的值
要是Map 为空，则调用 createMap 进行 ThreadLocalMap 对象初始化. 并将 this 即： threadlocal 和 value(对应的值) 作为第一个 entry 存放至 ThreadLocalMap 中

get()

获取当前线程绑定的局部变量

/**
 * 返回此线程局部变量的当前线程副本中的值。如果该变量对于当前线程没有值，则首先将其初始化为调用initialValue方法返回的值。
 * 返回值：该线程局部的当前线程的值
 *
 * @return the current thread's value of this thread-local
 */
public T get() {
  //获取当前 线程对象 和 ThreadLocalMap
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
      //如果 map 存在, 以当前的ThreadLocal为key,调用 getEntry 获取对应的存储实体e
        ThreadLocalMap.Entry e = map.getEntry(this);
      //对e进行判空
        if (e != null) {
            @SuppressWarnings("unchecked")
          //获取存储实体e对应的value值 ;  即为我们想要的当前线程对应此ThreadLocal的值
            T result = (T)e.value;
            return result;
        }
    }
   // map 不存在 或 map存在 但是没 和Map 相关联的 存储实体e
    return setInitialValue();
}

        /**
         * 获取与 key 关联的 entry。此方法本身仅处理快速路径：直接点击现有键。否则它会中继到 getEntryAfterMiss。
         * 这样做的目的是为了最大限度地提高直接命中的性能，部分原因是使该方法易于内联。
				 * 形参：key – 线程局部对象
				 * 返回值：与键关联的条目，如果没有这样的条目则为 null
         *
         * @param  key the thread local object
         * @return the entry associated with key, or null if no such
         */
        private Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }

    /**
     * set() 的变体，用于建立初始值。如果用户重写了 set() 方法，则使用它来代替 set() 方法。
     * 返回值：初始值
     * @return the initial value
     */
    private T setInitialValue() {
      // 调用 initialValue 获取初始化的值
  		// initialValue 可以被子类重写，如果不重写, 默认返回 null
        T value = initialValue();
      // 获取当前线程对象 和 ThreadLocalMap;
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
      // map 存在则设置 初始值
        if (map != null) {
            map.set(this, value);
        } else {
// 当前线程 Thread 不存在 ThreadLocalMap 对象. 则调用 createMap 进行 ThreadLocalMap 对象初始化. 并将 t 和 value(对应的值) 作为第一个 entry 存放至 ThreadLocalMap 中
            createMap(t, value);
        }
        if (this instanceof TerminatingThreadLocal) {
            TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
        }
        return value;
    }

    /**
     * 返回此线程局部变量的当前线程的“初始值”。
     该方法将在线程第一次使用get方法访问变量时被调用，除非该线程之前调用过set方法，在这种情况下，该线程将不会调用initialValue方法。
     通常，每个线程最多调用此方法一次，但如果随后调用remove然后调用get ，则可能会再次调用该方法。
     这个实现只是返回null ；如果程序员希望线程局部变量具有null以外的初始值，则必须对ThreadLocal进行子类化，并重写此方法。
     通常，将使用匿名内部类。
     返回值：该线程局部的初始值
     *
     * @return the initial value for this thread-local
     */
    protected T initialValue() {
        return null;
    }

    /**
     * 获取与 ThreadLocal 关联的映射。在 InheritableThreadLocal 中重写。
     *
     * @param  t the current thread
     * @return the map
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }


    /**
     * 创建与 ThreadLocal 关联的映射。在 InheritableThreadLocal 中重写
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

总结：代码执行流程

首先获取当前线程，根据当前线程获取一个Map

如果获取的Map不为空，则在Map中以ThreadLocal的引用作为key，在Map中获取对应的Entry e,否则转到4

如果e不为null,则返回e.value,否则转到4

Map为空或者e为空，则通过initialValue函数获取初始值value,然后用ThreadLocal的引用和value作为firstKey和firstValue创建一个新的Map

就是说：先获取当前线程的ThreadLocalMap变量，如果存在则返回值，不存在则创建初始值并返回初始值

remove()

移除当前线程绑定的局部变量

/**
 * 删除此线程局部变量的当前线程值。
 * 如果当前线程随后读取此线程局部变量，则将通过调用其initialValue方法重新初始化其值，除非当前线程在此期间设置了其值。这可能会导致当前线程中多次调用initialValue 方法
 * @since 1.5
 */
 public void remove() {
   //获取当前 线程对象 和 ThreadLocalMap
     ThreadLocalMap m = getMap(Thread.currentThread());
   //要是 map 存在就删除这个ThreadLocald对应的实体的entry
     if (m != null) {
         m.remove(this);
     }
 }

 private void remove(ThreadLocal<?> key) {
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);
            for (Entry e = tab[i];  e != null; e = tab[i = nextIndex(i, len)]) {
                if (e.get() == key) {
                    e.clear();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }

private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

            // expunge entry at staleSlot
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;

            // Rehash until we encounter null
            Entry e;
            int i;
            for (i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                    if (h != i) {
                        tab[i] = null;

                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

ThreadLocalMap 源码分析

在分析 ThreadLocal 方法的时候，我们了解到 ThreadLocal 的操作实际上时围绕 ThreadLocalMap 展开的。ThreadLocalMap 的源码相对比较复杂，主要从以下三个方面进行讨论。

// 只要线程处于  活动   状态并且ThreadLocal实例可访问，每个线程就持有对其线程局部变量副本的隐式引用；
// 线程消失后，其线程本地实例的  所有副本都将受到  垃圾回收（除非存在对这些副本的其他引用）。
public class ThreadLocal<T> {
  ...
/**
	*ThreadLocalMap 是一个定制的哈希映射，仅适用于维护线程本地值。
	不会将任何操作导出到 ThreadLocal 类之外。该类是包私有的，允许在类 Thread 中声明字段。
  为了帮助处理非常大且长期存在的使用情况，哈希表条目使用  弱引用  作为键。但是，由于不使用引用队列，因此仅当表开始空间不足时才保证删除陈旧 entry。
 */
  static class ThreadLocalMap {
    // 哈希映射中的 entry 继承了 WeakReference，使用其主 ref 字段作为键（始终是 ThreadLocal 对象）。
    // 请注意，空键（即entry.get() == null）意味着该键不再被引用，因此 这个 entry 可以从表中删除。
     static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
               /*
                  public WeakReference(T referent) {
                      super(referent);
                  }
              */
                value = v;
             
            }
     }
    ...
	}
  ...
}

1、基本结构

成员变量

/**
 * 初始容量, 必须是 2 的整数次幂
 */
public static final int INITIAL_CAPACITY = 16;

/**
 * 存放 数据
 * 同样, 数组的长度必须是 2 的整数次幂
 */
private Entry[] table;

/**
 * 数组里面 entry 的个数，就是存放数据的个数, 可以用于判断 table 当前的使用量是否超过阈值
 */
private int size = 0;

/**
 * 进行扩容的阈值, table 的使用量大于它的时候进行扩容.
 */
private int threshold;

存储结构 Entry

在 ThreadLocalMap 中, 也是使用 Entry 来保存 K-V 结构数据的。不过 Entry 中的Key只能是 ThreadLocal 对象，这点在构造方法中已经定死了。
Entry 继承自 WeakReference，也就是 key (ThreadLocal) 是弱引用，其 目的 是为了将 ThreadLocal 对象的生命周期和线程的生命周期解绑。

 static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
     }

2、hash冲突

ThreadLocal的在 set ()方法中有两处调用了ThreadLocalMap中的方法

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


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

ThreadLocalMap 的构造方法

 private static final int INITIAL_CAPACITY = 16;
 .......
/**
 * 构造一个最初包含（firstKey，firstValue）的新映射。 ThreadLocalMap 是惰性构造的，因此只有当我们至少有一个条目要放入其中时，我们才会创建一个。
 */
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
  // 初始化 table 
    table = new Entry[INITIAL_CAPACITY];
  // 计算索引(重点)：计算 fistKey 这个 ThreadLocal 在 table 中的存放位置
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
  // 创建 Entry 并放置到 table
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
  //设置阈值
    setThreshold(INITIAL_CAPACITY);  //  INITIAL_CAPACITY * 2/3
}

   private void setThreshold(int len) {
        threshold = len * 2 / 3;
   }

	Entry(ThreadLocal<?> k, Object v) {
    super(k);
    value = v;
  }
//  super(k);
		public WeakReference(T referent) {
        super(referent);                         ---------------->  // k 为 弱引用
    }

和hash 冲突有关系的代码： int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);

1.firstKey.threadLocalHashCode

private final int threadLocalHashCode = nextHashCode();

//ThreadLocals 依赖于附加到每个线程的每线程线性探针哈希图（Thread.threadLocals 和inheritableThreadLocals）。 ThreadLocal 对象充当键，通过 threadLocalHashCode 进行搜索。这是一个自定义哈希码（仅在 ThreadLocalMap 中有用），可消除常见情况下的冲突，即由相同线程使用连续构造的 ThreadLocals，同时在不太常见的情况下保持良好的行为。
private static int nextHashCode() {
      return nextHashCode.getAndAdd(HASH_INCREMENT);
}

//AutomicInteger 是一个提供原子操作的 Integer 类, 通过  线程安全  的方式操作加减，适合高并发的情况下使用.
private static AtomicInteger nextHashCode = new AtomicInteger();

//特殊的 hash 值：和   斐波拉契数列，黄金分割数 是有关系的。
//主要目的就是为了让哈希码能均匀的分布在2的n次方的数组里，也就是 Entry[] table 中，这样做可以尽量避免 hash 冲突。
private static final int HASH_INCREMENT = 0x61c88647;


public final int getAndAdd(int delta) {
     return unsafe.getAndAddInt(this, valueOffset, delta);
}


public final int getAndAddInt(Object var1, long var2, int var4) {
  int var5;
  do {
       var5 = this.getIntVolatile(var1, var2);
  } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
   return var5;
}

2. & (INITIAL_CAPACITY-1)

计算索引的时候采用的方法 hashcode & (size -1) 的方式，相当于取余操作 hashcode % size 更加高效一点，也正因为这一点所以 size 必须是 2 的整数幂次方，可以保证在索引不越界的情况下使得 hash 发生的冲突的次数减少

两种清理的方式

ThreadLocalMap 的set()

/**
 * 获取环形索引的下一个数组
 */
private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0;)    // 把 Entry[] table 看成是一个环形数组  没有越界就+1，越界了就从0 开始
}

// 向前移动一位
private static int prevIndex(int i, int len) {
  return ((i - 1 >= 0) ? i - 1 : len - 1);
}



private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    int len = tab.length;
  
    // 计算索引
    int i = key.threadLocalHashCode & (len - 1);
  
    /**
     * 重点代码：使用线性探测法查找元素
     */
     for(Entry e = tab[i];               e != null;                     e = tab[i = nextIndex(i, len)]) {  
       //从 当前 tab[i] 的entry    要是entry != null,执行下面的逻辑 (说明有hash 冲突)      e先后移动一位，成为新的tab[i]对应的元素
         ThreadLocal<?> k = e.get();  
         if(k == key) {         // 要是ThreadLocal 对应的key 存在，则覆盖之前的值，返回
             e.value = value;
             return;
         }
// key=null, 但是 e!=null (未及时 remove, 但之前放置此位置 ThreadLocal对象（key）被回收的时候), 当前数组中的 Entry 是一个陈旧的元素.
         if(k == null) {
             replaceStaleEntry(key, value, i);
             return;
         }
     }
    tab[i] = new Entry(key, value); //ThreadLocal对应的 key 不存在，且没有找到陈旧的元素(e==null)，则在 对应位置 tab[i] 创建一个新的 Entry
    int sz = ++size;  // 数组长度++ 
  //若未清理到任何数据且size超过阈值threshold（len*2/3）则rehash()，rehash()中会先进行探测式清理过期元素，若此时size>=len/2(threshold-threshold/4)则扩容
    if(!cleanSomeSlots(i, sz) && sz >= threshold) // i 是重新计算的 hash   sz 是数组的长度
        rehash();
}

 // 用新的元素替换成旧的元素，这个进行了不少的垃圾清理动作, 防止内存泄漏
 private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) {  // staleSlot 当前（陈旧）的槽位
            Entry[] tab = table;
            int len = tab.length;
            Entry e;

            //备份以检查当前运行中先前的陈旧条目。我们一次清除整个运行，以避免由于垃圾收集器成批释放引用（即每当收集器运行时）而导致持续的增量重新哈希。
            int slotToExpunge = staleSlot;    //slotToExpunge 要删除的插槽   = 陈旧的槽
            for (int i = prevIndex(staleSlot, len);     (e = tab[i]) != null;      i = prevIndex(i, len))
              //   槽位为前一个                             当前 tab[i] 不是  null        槽位向前遍历  
                if (e.get() == null)       // 要是  key  == null
                    slotToExpunge = i;      // 要删除的插槽  就是最新的当前槽位
						// 要是  所有的 key  != null 或者 e == null退出循环
   
         
            for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null;   i = nextIndex(i, len)) {
              //   槽位为下一个                       当前 tab[i] 不是 null        槽位向后遍历  
                ThreadLocal<?> k = e.get();
                // 如果我们找到键，那么我们需要将它与过时的条目交换以维持哈希表顺序。
              // 然后可以将新的过时槽 或在器其前后遇到的任何其他过时槽发送到 expungeStaleEntry 以删除或重新散列所有其他条目在运行中。
              
              //k 出现重复
                if (k == key) {  // k 存在就 value 进行覆盖，并将现在的槽位变为原来的槽位，原来的槽位改为当前值
                    e.value = value;   
                    tab[i] = tab[staleSlot];
                    tab[staleSlot] = e;   //这两行的交换两个元素的位置的作用就是 将原来在前面的 key = null 的tab[旧槽]元素后移，
                    // 当前出现key重复的元素 tab[i] 前移，使得元素之间  可以 维持哈希表顺序
                  
                    // 如果之前的过时条目存在，则开始删除
                    if (slotToExpunge == staleSlot)   // 要删除的插槽 是 旧的槽位
                        slotToExpunge = i;            // 要删除的插槽  就是最新的当前槽位
                    cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); //清空null 
                    return;
                }

                //如果我们在向后扫描时没有找到过时条目，则扫描 key 时看到的第一个过时条目是运行中仍然存在的第一个条目。
                if (k == null && slotToExpunge == staleSlot) //要是k == null && 要删除的插槽 是 旧的槽位 那么要删除的插槽==最新的当前槽位
                    slotToExpunge = i;
            }

            // 要是key==k 使用不成立,就在当前位置插上这个元素
            tab[staleSlot].value = null;
            tab[staleSlot] = new Entry(key, value);

            //再次清空一下 
            if (slotToExpunge != staleSlot)
                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
        }


   /**
     * cleanSomeSlots 用于清除那些 e.get() == null 的元素（即, key 为 null 的元素）.
     * 这种数据 key 关联的对象已经被回收了，所以这个 Entry(table[index]) 可以被置为 null,
     * 如果没有清除任何 entry, 并且当前使用量的达到了 负载因子 所定义的 2/3, 那么进行 rehash (执行一次全表的，扫描清理工作)
     */
  private boolean cleanSomeSlots(int i, int n) {
            boolean removed = false;
            Entry[] tab = table;
            int len = tab.length;
            do {
                i = nextIndex(i, len);  // i 向后移
                Entry e = tab[i];				// 得到 tab  对应位置的元素
                if (e != null && e.get() == null) {  
                    n = len;
                    removed = true;
                    i = expungeStaleEntry(i);  
     //expungeStaleEntry作用：
             // 1、要是 e != null && e.get() == null 删除原来数组中对应位置的 entry 
             // 2、挨个遍历数组之后的 元素 :  要是(e = tab[i]) != null &&  e.get() == null   删除该位置元素并置为null
                               //         要是(e = tab[i]) != null &&  e.get() !=  null   重新hash, 重新分配位置, 并 减少hash 冲突
             // 3、返回的 i 就是 (e = tab[i])  == null 的位置
                }
            } while ( (n >>>= 1) != 0); //我的理解： do 里面是清空了 i~n 中的元素，n >>> 1 是缩小范围，i每次都会变化，二分式减少搜索的时间，提升效率，时间复杂度只有O(n)
            return removed;
        }

	private int expungeStaleEntry(int staleSlot) { // 此时 key 为 null
            Entry[] tab = table;
            int len = tab.length;

            // expunge entry at staleSlot
            tab[staleSlot].value = null; //    将值变为 null 
            tab[staleSlot] = null;     // 将这个位置的 槽 也设置为 null
            size--;                // map 的长度--

            // Rehash until we encounter null
            Entry e;
            int i;
            for (i = nextIndex(staleSlot, len);   (e = tab[i]) != null;		   i = nextIndex(i, len)) {      
                 // 从key = null 的槽的 下一位开始   // 只要 该位置不是null          //向后移动		
                ThreadLocal<?> k = e.get();
                if (k == null) {              // 要是下一个位置的 key  也是 null ，是的话就全部设置为 null,清空
                    e.value = null;  // 这里
                    tab[i] = null;
                    size--;
                } else { // 下一个 key 不是null 
                    int h = k.threadLocalHashCode & (len - 1); // 防止发生hash冲突的key 移位,此时要重新计算下k
                    if (h != i) {                   //判断这个新的下标是不是不等于 i (i 为原来 发生 hash 冲突的位置)
                        tab[i] = null;   						// 要是不等于，说明发生了 hash冲突，那么就要 把 原来的位置变为 null
                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        while (tab[h] != null)			 
                            h = nextIndex(h, len);   // 对于新的位置不是 null， 那么h就要后移一位
                        tab[h] = e;   // 对发生 hash 冲突元素的上移到清空的位置
                    }
                }
            }
            return i;
        }

set() 的执行流程

首先根据 key 计算索引 i , 然后循环在数组中查找 i 位置的上 Entry。
若是 Entry 已经存在
2.1 key 等于传入的 key，那么这个时候直接给这个 Entry 赋新的 value 值。
2.2 key 为 null，则调用的 replaceStaleEntry 在对应的 key 为空 Entry 插入此时的值。
直到循环中判断得到 Entry为 null；那么就在此处新建一个Entry，并且插入，size + 1。
最后调用 cleanSomeSlots，清理 key 为 null 的Entry，最后返回是否清理了 Entry 并判断 sz ≥ threshold 达到 rehash 条件，达到的话就会调用 rehash 函数执行一次全表的扩容的工作。

线性探测法解决hash 冲突：

该方法依次探测下一个地址，直到有空的地址，进行插入，若整个空间都找不到空余的地址，则产生溢出。

举个例子：假设当前的 tab 长度为 16，也就是说如果计算出来 key 的索引为 14，如果 table[14] 上已经有值，并且 key 与当前 key 不一致，那么就发生了hash冲突，这个时候将 14 + 1 得到 15，取 table[15] 进行判断，这个时候如果还是冲突就会返回 0 ，取 table[0]，依次类推，直到可以插入。

按照上面这个描述，可以把 Entry[] table 看成是一个环形数组。

ThreadLocalMap的 rehash()

// 扩容 
private void rehash() {
  expungeStaleEntries();  // 对原来槽位的
  // Use lower threshold for doubling to avoid hysteresis
  if (size >= threshold - threshold / 4)  //  size >= 阈值的3/4  （初始值len * 2/3 * 3/4）
    resize();
}

		private void resize() {
            Entry[] oldTab = table; 
            int oldLen = oldTab.length; // 老数组的大小
            int newLen = oldLen * 2;  // 扩大两倍
            Entry[] newTab = new Entry[newLen];//新数组
            int count = 0;

            for (int j = 0; j < oldLen; ++j) { // 遍历老的数组
                Entry e = oldTab[j];  // 获取每个值
                if (e != null) {     //只要 Entry e 不是null
                    ThreadLocal<?> k = e.get(); // 取 e 的 key
                    if (k == null) {      //key 的值要是null   就把value也设置为 null
                        e.value = null; // Help the GC
                    } else {
                        int h = k.threadLocalHashCode & (newLen - 1);  // 否则的话就重新计算 hash
                        while (newTab[h] != null)   // 新数组计算出来的位置要是不是 null  （解决 hash 冲突）
                            h = nextIndex(h, newLen);  //h 后移
                        newTab[h] = e;  // 直到新数组对应的位置是空的  才把tab对应的位置设置为老数组获取的值 
                        count++;  // 数组长度++ 
                    }
                }
            }
            setThreshold(newLen);   // 重新设置阈值
            size = count;   //  数组长度  就是 count
            table = newTab; //  此时用 新数组取代老数组
        }

			private void expungeStaleEntries() {
            Entry[] tab = table;
            int len = tab.length;
            for (int j = 0; j < len; j++) {
                Entry e = tab[j];
                if (e != null && e.get() == null)   // entry e 不是空 但是 key 删除了，防止内存泄漏
                    expungeStaleEntry(j);  
//expungeStaleEntry作用：
             // 1、要是 e != null && e.get() == null 删除原来数组中对应位置的 entry 
             // 2、挨个遍历数组之后的 元素 :  要是(e = tab[i]) != null &&  e.get() == null   删除该位置元素并置为null
                               //         要是(e = tab[i]) != null &&  e.get() != null   重新hash, 重新分配位置, 并 减少hash 冲突 
             // 3、返回的 i 就是 (e = tab[i])  == null 的位置
            } 
        }

ThreadLocalMap 的remove()

private void remove(ThreadLocal<?> key) {
    Entry[] tab = table;
    int len = tab.length; //table的长度
    int i = key.threadLocalHashCode & (len-1);  //计算hash 值
    for (Entry e = tab[i];  e != null; e = tab[i = nextIndex(i, len)]) { //i 后移一位,得到数组 对应下标的 值
        if (e.get() == key) {  //获取key 
            e.clear();	// 置为 null
            expungeStaleEntry(i);  // 原来的槽位就是 i，删除这个槽位的之后对原来的数组 重新hash ,重新分配位置，减少 hash 冲突 或者删除这个元素
            return;
        }
    }
}

public abstract class Reference<T> {
		....
    private T referent;         /* Treated specially by GC */
   	public void clear() {
        this.referent = null;
    }
    ...
}
 		private int expungeStaleEntry(int staleSlot) { //原来的槽位
            Entry[] tab = table;
            int len = tab.length;

            // expunge entry at staleSlot
            tab[staleSlot].value = null; // 数组中对应的位 的 值value 设置为 null
            tab[staleSlot] = null;       // 数组对应的值 设置为 null
            size--;												// 数组长度--

            // Rehash until we encounter null
            Entry e;
            int i;
            for (i = nextIndex(staleSlot, len);      (e = tab[i]) != null;   i = nextIndex(i, len)) {
              //   i 为原来槽位的下一个位置，记为当前槽位     当前槽位的值不是空的     槽位 继续向下移动
                ThreadLocal<?> k = e.get(); // 当前槽位的不是 null  就 获取对应的 key
                if (k == null) {     // 当前槽位的 key  是null
                    e.value = null;  // 清空（置空）当前槽位的值
                    tab[i] = null;
                    size--;         // 数组大小--
                } else {    // 当前槽位的 key  不是null
                    int h = k.threadLocalHashCode & (len - 1); // 因为临近的值已经置为空了，防止当前值是被hash冲突之后确定的值，所以此处要的重新计算hash
                    if (h != i) {              //和 重新 hash  的值不一样，说明 原值 有hash 冲突的，那么就将 原来槽位值置为空
                        tab[i] = null;

                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        while (tab[h] != null) // 防止新的hash 冲突，槽位 后移
                            h = nextIndex(h, len);
                        tab[h] = e;  // 在没有hash 冲突的位置 置为新的Entry 
                    }
                }
            }
            return i; // i 就是 (e = tab[i])  == null 的位置
        }

ThreadLocalMap 的 getEntry()

// getEntry
private Entry getEntry(ThreadLocal<?> key) {
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    if (e != null && e.get() == key)  
        return e;
    else
        return getEntryAfterMiss(key, i, e);  //这里
}

 private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;

            while (e != null) {
                ThreadLocal<?> k = e.get();
                if (k == key)
                    return e;
                if (k == null)
                    expungeStaleEntry(i);//这里,要是 key 为null 就删除做个 entry，i  为 槽位（下标）
                else
                    i = nextIndex(i, len);// i 槽位后移
                e = tab[i];
            }
            return null;
        }

3、使用

//可以debug 
public class MyThreadLocal {
    public static ThreadLocal<Long>  y = new ThreadLocal<>();
    public static ThreadLocal<Long>  x = new ThreadLocal(){
        @Override
        protected Long initialValue(){
            System.out.println("initial value ");
            return Thread.currentThread().getId();
        }
    };
    public static void main(String[] args) {
        System.out.println(x.get());
        x.set(200L);
        System.out.println(x.get());//200
//        System.out.println(y.get()); //null
        new Thread(()->{
            System.out.println(x.get());
        }).start();
    }
}

class  M{
    private String content;
    private static  volatile ThreadLocal<String>  threadLocal = new ThreadLocal<>();
    public String getContent() {
        String res = threadLocal.get();
        return res;
    }
    public void setContent(String content) {
        threadLocal.set(content);
    }

    public static void main(String[] args) {
        M m = new M();
        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                m.setContent(Thread.currentThread().getName());
                System.out.println("------------------------------");
                System.out.println(Thread.currentThread().getName()+"-->"+m.getContent());
            }).start();
        }
    }
}

结合Spring 使用

package com.ry.learning.study.Threadlocal_;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyThreadlocal_ {
    Integer c = 0;
  
    @RequestMapping("/start")
    public Integer read(){
        return x.get();
    }

    @RequestMapping("/end")
    public  Integer write1(){
        c++;
        return 1;
    }
}


执行：
ab -n 10000 -c 1 localhost:8080/end    
curl localhost:8080/start           
结果 10000
  
  
但是执行：
ab -n 10000 -c 100 localhost:8080/end    
curl localhost:8080/start   
结果 是小于10000的
  
  
  
// ===========> 改进一 使用同步锁
package com.ry.learning.study.Threadlocal_;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyThreadlocal_ {
    Integer c = 0;
    @RequestMapping("/start")
    public Integer read(){
        return x.get();
    }
    @RequestMapping("/end2")
    public  Integer write2(){
        add();
        return 1;
    }
    synchronized void add(){
        c++;
    }
}

执行：
ab -n 10000 -c 100 localhost:8080/end    
curl localhost:8080/start           
结果 10000
// 但是排队阻塞等待的结果太久了 
  
  
  
//改进二： 使用ThreadLocal
package com.ry.learning.study.Threadlocal_;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyThreadlocal_ {
    Integer c = 0;
    static  ThreadLocal<Integer> x = new ThreadLocal(){
        @Override
        protected Integer initialValue(){
            return 0;
        }
    };
    @RequestMapping("/start")
    public Integer read(){
        return x.get();
    }


    @RequestMapping("/end")
    public  Integer write(){
        x.set(x.get() +1);
        return 1;
    }
}

执行：
ab -n 10000 -c 1 localhost:8080/end    
curl localhost:8080/start           
结果 10000
执行结果 每次调用 curl localhost:8080/start 查询的结果是不一样的
  

  
  
// =============================>   改进
  
package com.ry.learning.study.Threadlocal_;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashSet;

@RestController
public class MyThreadlocal_ {
    static  HashSet<Val<Integer>> set= new HashSet<>();
    Integer c = 0;
    static  ThreadLocal<Val<Integer>> x = new ThreadLocal(){
        @Override
        protected Val<Integer> initialValue(){
            Val<Integer> val = new Val<>();
            val.setV(0);
            set.add(val);
            return val;
        }
    };
    @RequestMapping("/start")
    public Integer read(){
        return set.stream().map(x -> x.getV()).reduce((a, x) -> a + x).get();
    }


    @RequestMapping("/end")
    public  Integer write(){
        add();
        return 1;
    }// 每次调用 curl localhost:8080/start 查询的结果是不一样的


    synchronized void add(){
        Val<Integer> val = x.get();
        val.setV(val.getV() + 1);
    }
}
 


执行：
ab -n 10000 -c 100 localhost:8080/end
curl localhost:8080/start
结果：
10000
  

  
// ---------> 无法在多个  ThreadLocal 中收集数据
// 使用hashmap  或者  hashset 
package com.ry.learning.study.Threadlocal_;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


import java.util.HashSet;

@RestController
public class MyThreadlocal_ {
    static HashSet<Val<Integer>> set = new HashSet<>();

    synchronized static void _add(Val<Integer> v) {
        /* 这一段有 竞争的问题,可能会是临界区 */
        set.add(v);
    }

    static ThreadLocal<Val<Integer>> x = new ThreadLocal() {
        @Override
        protected Val<Integer> initialValue() {
            Val<Integer> val = new Val<>();
            val.setV(0);
            _add(val); // 虽然这一段加上了锁，但是性能没什么问题，因为只有在初始化的时候才会加锁，顶多就是在创建 ThreadLocal 的时候执行的
            return val;
        }
    };

    @RequestMapping("/start")
    public Integer read() {
        return set.stream().map(x -> x.getV()).reduce((a, x) -> a + x).get();
    }

    @RequestMapping("/end")
    public Integer write() {
        add();
        return 1;
    }


    void add() {
        Val<Integer> val = x.get();
        val.setV(val.getV() + 1);
    }
}


public class Val<T> {
    T v ;
    public T getV(){
        return v;
    }
    public void setV(T v){
        this.v =v;
    }
}

执行：
ab -n 100000 -c 100 localhost:8080/end
curl localhost:8080/start
结果：
10000
  
执行：
ab -n 10000 -c 100 localhost:8080/end
curl localhost:8080/start
结果：
10000

启发：

完全避免同步（难）
缩小同步范围（简单）+ThreadLocal解决问题

ThreadLocal 的问题

1、弱引用和内存泄漏

误区：内存泄漏和 Entry 中key 是弱引用相关的

内存相关概念？

Memory overflow：内存溢出，没有足够的内存给内存的申请者使用。
Memory leak：内存泄漏指的是程序中 已动态分配的堆内存 由于某种原因未释放或者无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。
内存泄漏的堆积导致内存溢出。

引用相关

强引用: new 出来的对象，只有没有对象进行引用的时候才会在垃圾回收的时候回收，否则即使有内存溢出或者内存泄漏也不会被回收
软引用: 内存不够的时候回收 (缓存)
弱引用: 垃圾回收时才进行回收 (防止内存泄漏)
虚引用: 用于接受将死的对象

key 为强引用会怎么办？

如果使用了 ThreadLocal ，随后threadLocal Ref 被回收了。
但是因为 threadLocalMap 的 Entry 中的 key是强引用，引用的是 ThreadLocal，造成 ThreadLocal 无法被回收。
要是在没有手动删除这个 Entry 以及 CurrentThread 依然运行的前提下，使用有强引用链 currentthread Ref →Thread → threadLocalMap → entry , entry 就不会被回收（Entry当中包含了 ThreadLocal 实例(key)和value）, 从而就会导致 Entry 的内存泄漏。

ThreadLocalMap 中的 key 使用了强引用，是无法避免内存泄漏的。

key 为弱引用会怎么办？

代码中使用了 ThreadLocal，随后 ThreadLocalRef 会被回收。
由于 ThreadLocalMap 持有 Entry 的弱引用，没有任何强引用指向 ThreadLocal实例，所以 ThreadLocal 就可以顺利被gc回收，此时垃圾回收之后Entry 的 key = null.
要是在没有手动删除这个 Entry 以及 CurrentThread 依然运行的前提下，使用有强引用链 currentthread Ref →Thread → threadLocalMap → entry , entry 就不会被回收（Entry当中包含了 ThreadLocal 实例(key)和value）, 从而就会导致 Entry 的内存泄漏。

ThreadLocalMap 的 key 使用了弱引用，也可能导致内存泄漏的问题。

总结

无论 ThreadLocalMap 的 key 使用的是强 / 弱引用，只要在没有手动删除这个 Entry 以及 CurrentThread 依然运行的前提下都可能导致内存泄漏的问题。

出现内存泄漏的本质!

可以看出上述两个问题无论 key 是哪一中引用，都会有内存泄漏的本质是两个前提条件导致的：

没有手动删除这个Entry，
CurrentThread 依然运行。（只有当 CurrentThread 销毁，则指向 ThreadLocalMap的引用链就断了，进而引发后续链条上全部对象GC）

所以ThreadLocal 内存泄漏的根源是：

ThreadLocalMap 的生命周期跟 Thread 一样导致的；【ThreadLocal 的底层结构决定的】，如果没有手动删除对应的key，就会导致内存泄漏。

为什么 key 还是使用弱引用?

为什么弱引用也有内存泄漏但是 key 还是使用弱引用呢？

首先要明确避免内存泄露的两种方式：

使用完ThreadLocal 之后，手动 remove 掉对应的Entry
使用完ThreadLocal 之后, 结束当前 Thread

但是第二种方式无法控制，特别是使用线程池的时候，线程即使结束也不一定会立即销毁。

应该采用方式一避免内存泄漏，无论强弱引用只要使用完及时手动 remove 删掉就好了，那为什么还要使用弱引用呢？

因为ThreadLocalMap 中在执行 set 和 getEntry 方法中，会对 key 为 null （即 ThreadLocal对象 ==null ？）进行判断；如果为 null 的话，那么 value 也会置为 null。

也就是说：使用完 ThreadLocal 但是 CurrentThread 依然运行的前提下，就算没有调用 remove 方法，弱引用可以比强引用多一层保障(见下面的ThreadLocalMap 的 getEntry 和 set 源码)；因为弱引用的 ThreadLocal 会被回收，这样 key 就会变为 null；对应的value在下一次调用 set、get、remove 中任何一个方法的时候会被清除，从而避免内存泄漏。

2、数据传递的问题

问题：

在异步的场景之下，无法给子线程共享父线程中创建的线程副本数据的。

解决方法：

使用 InheritableThreadLocal

public class TransmittableThreadLocalDemo {
    public static void main(String[] args) {
        ThreadLocal<String> threadLocal = new ThreadLocal<>();
        ThreadLocal<String> inheritableThreadLocal = new InheritableThreadLocal<>();
        threadLocal.set("threadLocal 拿到的 父进程数据");
        inheritableThreadLocal.set("inheritableThreadLocal 拿到的 父类的数据");
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("子线程的获取的父类的数据：" + threadLocal.get());
                System.out.println("子线程的获取的父类的数据：" + inheritableThreadLocal.get());
            }
        }).start();
    }
}

子线程的获取的父类的数据：null
子线程的获取的父类的数据：inheritableThreadLocal 拿到的 父类的数据

原理：

在父线程中使用的是 new Thread() 创建子线程，Thread#init() 的方法就可以在Thread构造方法中被调用，init()的方法的作用就是拷贝 父线程的数据到子线程中

源码

public Thread(Runnable target) {
  init(null, target, "Thread-" + nextThreadNum(), 0);
}

private void init(ThreadGroup g, Runnable target, String name, long stackSize) {
  init(g, target, name, stackSize, null, true);
}

 private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

      .......
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =  ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        /* Stash the specified stack size in case the VM cares */
        this.stackSize = stackSize;

        /* Set thread ID */
        tid = nextThreadID();
    }

不足：

如果不是使用 new Thread() 的方式【比如使用线程池的方式创建，线程池是基于线程复用的逻辑的】创建线程就仍然会有父子进程之间数据无法传输的问题

终级解决之道：

TransmittableThreadLocal

使用

TransmittableThreadLocal并配合TtlExecutors.getTtlExecutorService()可以让子线程感知到父线程对共享变量的实时变化。package com.ry.learning.study.Threadlocal_;

import com.alibaba.ttl.TransmittableThreadLocal;
import com.alibaba.ttl.threadpool.TtlExecutors;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TransmittableThreadLocal_ {
    static TransmittableThreadLocal<String> local = new TransmittableThreadLocal<>();
    public static void main(String[] args) {
        local.set("rycan");
        ExecutorService pool = TtlExecutors.getTtlExecutorService(Executors.newFixedThreadPool(3));
        pool.submit(()->{
            System.out.println("线程："+ Thread.currentThread().getName()+ local.get());
        });
      
        local.set("rycan.top");
        pool.submit(()->{
            System.out.println("线程："+ Thread.currentThread().getName()+ local.get());
        });
        pool.shutdown();
    }
}


线程：pool-1-thread-1rycan
线程：pool-1-thread-2rycan.top

TransmittableThreadLocal并配合TtlExecutors.getTtlExecutorService()可以让子线程感知到父线程对共享变量的实时变化

package com.ry.learning.study.Threadlocal_;

import com.alibaba.ttl.TransmittableThreadLocal;
import com.alibaba.ttl.threadpool.TtlExecutors;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TransmittableThreadLocal_ {
    static TransmittableThreadLocal<String> local = new TransmittableThreadLocal<>();
    public static void main(String[] args) {
       local.set("rycan");
        ExecutorService pool = TtlExecutors.getTtlExecutorService(Executors.newFixedThreadPool(3));
        pool.submit(()->{
            System.out.println("线程1："+ Thread.currentThread().getName()+ local.get());
        });
        local.set("rycan.top");
        pool.submit(()->{
            local.set("rycan ");
            System.out.println("线程2："+ Thread.currentThread().getName()+ local.get());
        });

        pool.submit(()->{
            System.out.println("线程3："+ Thread.currentThread().getName()+ local.get());
        });
        pool.shutdown();
    }
}


线程1：pool-1-thread-1rycan
线程2：pool-1-thread-2rycan 
线程3：pool-1-thread-3rycan.top

子线程对父线程值的修改只会影响当前运行时子线程，不影响父线程和其他子线程，也不影响下次运行

原理：

和从ThreadLocal中保存在Thread中不同的是，此处TransmittableThreadLocal 中有一个属性为 holder

源码版本 2.14.2

TtlExecutors对普通的ExecutorService进行了封装

ExecutorService pool = TtlExecutors.getTtlExecutorService(Executors.newFixedThreadPool(3));

pool.submit(()->{ local.set("rycan "); System.out.println("线程2："+ Thread.currentThread().getName()+ local.get()); });

/**
	所有的方法都是线程安全的
 */
public final class TtlExecutors {


  // 封装的 ExcutorService
    @Nullable
    @Contract(value = "null -> null; !null -> !null", pure = true)
    public static ExecutorService getTtlExecutorService(@Nullable ExecutorService executorService) {
        if (TtlAgent.isTtlAgentLoaded() || executorService == null || executorService instanceof TtlEnhanced) {
            return executorService;
        }
        return new ExecutorServiceTtlWrapper(executorService, true);
    }
  ....
}

 

class ExecutorServiceTtlWrapper extends ExecutorTtlWrapper implements ExecutorService, TtlEnhanced {
    private final ExecutorService executorService;
    ExecutorServiceTtlWrapper(@NonNull ExecutorService executorService, boolean idempotent) {
        super(executorService, idempotent);
      
     /*
         ExecutorTtlWrapper(@NonNull Executor executor, boolean idempotent) {
            this.executor = executor;
            this.idempotent = idempotent;
        }
     */
        this.executorService = executorService;
    }
		...
    @NonNull
    @Override
    public Future<?> submit(@NonNull Runnable task) {
        return executorService.submit(TtlRunnable.get(task, false, idempotent));
    }
  ...
}


public final class TtlRunnable implements Runnable, TtlWrapper<Runnable>, TtlEnhanced, TtlAttachments {
  
  		
      @Nullable
      @Contract(value = "null, _, _ -> null; !null, _, _ -> !null", pure = true)
      public static TtlRunnable get(@Nullable Runnable runnable, boolean releaseTtlValueReferenceAfterRun, boolean idempotent) {
          if (runnable == null) return null;

          if (runnable instanceof TtlEnhanced) {
              // avoid redundant decoration, and ensure idempotency
              if (idempotent) return (TtlRunnable) runnable;
              else throw new IllegalStateException("Already TtlRunnable!");
          }
          return new TtlRunnable(runnable, releaseTtlValueReferenceAfterRun);
      }
  
        private TtlRunnable(@NonNull Runnable runnable, boolean releaseTtlValueReferenceAfterRun) {
                this.capturedRef = new AtomicReference<>(capture());
                this.runnable = runnable;
                this.releaseTtlValueReferenceAfterRun = releaseTtlValueReferenceAfterRun;
        }

  
  
   @Override
    public void run() {
     		// capturedRef 是主线程传递下来的ThreadLocal的值。
        final Object captured = capturedRef.get();
        if (captured == null || releaseTtlValueReferenceAfterRun && !capturedRef.compareAndSet(captured, null)) {
            throw new IllegalStateException("TTL value reference is released after run!");
        }

      //backup  是子线程已经存在的ThreadLocal变量，将 captured 的值以快照的方式重做到执行线程
        final Object backup = replay(captured);
        try {
            runnable.run();
        } finally {
          //在子线程任务中，ThreadLocal可能发生变化，该步骤的目的是  回滚进入前的ThreadLocal的线程
            restore(backup);
        }
    }
  
}

public class TransmittableThreadLocal<T> extends InheritableThreadLocal<T> implements TtlCopier<T> {
  	...
  	 private final boolean disableIgnoreNullValueSemantics;

    // 1. holder 本身是一个InheritableThreadLocal(a ThreadLocal)
    // 2. holder 的 类型为WeakHashMap<TransmittableThreadLocal<Object>, ?>
      // 2.1 但WeakHashMap作为Set使用：WeakHashMap的值始终为null，并且从未使用过。 
      // 2.2 WeakHashMap支持null值。
      private static final InheritableThreadLocal<WeakHashMap<TransmittableThreadLocal<Object>, ?>> holder =
            new InheritableThreadLocal<WeakHashMap<TransmittableThreadLocal<Object>, ?>>() {
                @Override
                protected WeakHashMap<TransmittableThreadLocal<Object>, ?> initialValue() {
                    return new WeakHashMap<>();
                }

                @Override
                protected WeakHashMap<TransmittableThreadLocal<Object>, ?> childValue(WeakHashMap<TransmittableThreadLocal<Object>, ?> parentValue) {
                    return new WeakHashMap<TransmittableThreadLocal<Object>, Object>(parentValue);
                }
            };
      
    // 将此线程局部变量的当前线程副本设置为指定值。大多数子类不需要重写此方法，仅依靠initialValue方法来设置线程局部变量的值。
       @Override
      public final void set(T value) {
          if (!disableIgnoreNullValueSemantics && value == null) {
              //不能设置就 remove()
              remove();
          } else {
              super.set(value);
              addThisToHolder();
          }
      }
  
   private void addThisToHolder() {
        if (!holder.get().containsKey(this)) {
            holder.get().put((TransmittableThreadLocal<Object>) this, null); // WeakHashMap supports null value.
        }
    }
  
  
  
   @NonNull
        public static Object replay(@NonNull Object captured) {
          // 获取父线程ThreadLocal快照
            final Snapshot capturedSnapshot = (Snapshot) captured;

            final HashMap<Transmittee<Object, Object>, Object> transmittee2Value = newHashMap(capturedSnapshot.transmittee2Value.size());
            //遍历 holder，从 父线程继承过来的,或者之前注册进来的 
            for (Map.Entry<Transmittee<Object, Object>, Object> entry : capturedSnapshot.transmittee2Value.entrySet()) {
                Transmittee<Object, Object> transmittee = entry.getKey();
                try {
                    Object transmitteeCaptured = entry.getValue();
                  transmittee2Value.put(transmittee,transmittee.replay(transmitteeCaptured));
                } catch (Throwable t) {
                    if (logger.isLoggable(Level.WARNING)) {
                        logger.log(Level.WARNING, "exception when Transmitter.replay for transmittee " + transmittee +
                                "(class " + transmittee.getClass().getName() + "), just ignored; cause: " + t, t);
                    }
                }
            }
            return new Snapshot(transmittee2Value);
        }
  
  
  
  
  private static final Transmittee<HashMap<TransmittableThreadLocal<Object>, Object>, HashMap<TransmittableThreadLocal<Object>, Object>> ttlTransmittee =
                new Transmittee<HashMap<TransmittableThreadLocal<Object>, Object>, HashMap<TransmittableThreadLocal<Object>, Object>>() {
                    @NonNull
                    @Override
                    public HashMap<TransmittableThreadLocal<Object>, Object> capture() {
                        final HashMap<TransmittableThreadLocal<Object>, Object> ttl2Value = newHashMap(holder.get().size());
                        for (TransmittableThreadLocal<Object> threadLocal : holder.get().keySet()) {
                            ttl2Value.put(threadLocal, threadLocal.copyValue());
                        }
                        return ttl2Value;
                    }

                    @NonNull
                    @Override
                    public HashMap<TransmittableThreadLocal<Object>, Object> replay(@NonNull HashMap<TransmittableThreadLocal<Object>, Object> captured) {
                        final HashMap<TransmittableThreadLocal<Object>, Object> backup = newHashMap(holder.get().size());

                        for (final Iterator<TransmittableThreadLocal<Object>> iterator = holder.get().keySet().iterator(); iterator.hasNext(); ) {
                            TransmittableThreadLocal<Object> threadLocal = iterator.next();

                            // backup
                            backup.put(threadLocal, threadLocal.get());

                            // clear the TTL values that is not in captured
                            // avoid the extra TTL values after replay when run task
                            // 清除本次没有传递过来的 ThreadLocal，和对应值
                                //  -- 第一点：可能会有因为 InheritableThreadLocal 而传递并保留的值
                                //  -- 第二点：保证主线程set过的ThreadLocal不被传递过来。明确其传递是由业务代码控制，就是明确 set 过值的


                            if (!captured.containsKey(threadLocal)) {
                                iterator.remove();
                                threadLocal.superRemove();
                            }
                        }

                        // set TTL values to captured
                        // 将 map 中的值，设置到快照 , 内部调用了 beforeExecute 和 afterExecute 方法。默认不做任何处理
                        setTtlValuesTo(captured);

                        // call beforeExecute callback     TransmittableThreadLocal 的回调方法，在任务执行前执行
                        doExecuteCallback(true);

                        return backup;
                    }

                    @NonNull
                    @Override
                    public HashMap<TransmittableThreadLocal<Object>, Object> clear() {
                        return replay(newHashMap(0));
                    }

                    @Override
                    public void restore(@NonNull HashMap<TransmittableThreadLocal<Object>, Object> backup) {
                        // call afterExecute callback   调用执行完后回调接口
                        doExecuteCallback(false);
                      //  移除子线程新增的TTL
								      for (final Iterator<TransmittableThreadLocal<Object>> iterator = holder.get().keySet().iterator(); iterator.hasNext(); ) {
                            TransmittableThreadLocal<Object> threadLocal = iterator.next();

                            // clear the TTL values that is not in backup  
                            // avoid the extra TTL values after restore
                            //恢复快照时，清除本次传递注册进来，但是原先不存在的 TransmittableThreadLocal
        										// 移除掉所有不在备份里面的TTL数据，应该是为了避免内存泄漏吧
                            if (!backup.containsKey(threadLocal)) {
                                iterator.remove();
                                threadLocal.superRemove();
                            }
                        }
                        // restore TTL values 重置为原来的数据(就是恢复回备份前的值)
                        setTtlValuesTo(backup);
                    }
                };
}

private static void setTtlValuesTo( WeakHashMap<TransmittableThreadLocalCode<Object>, Object> ttlValues) {
     for (Map.Entry<TransmittableThreadLocalCode<Object>, Object> entry : ttlValues.entrySet()) {
        TransmittableThreadLocalCode<Object> threadLocal = entry.getKey();
        // set 的同时，也就将 TransmittableThreadLocal 注册到当前线程的注册表了
        threadLocal.set(entry.getValue());
     }
}

1、将父线程的 TTL 传到 TtlRunnable 的构造方法中，

2、将子线程的 TTL 值进行备份

3、将主线程的 TTL 设置到子线程中（value 是对象引用，仍然会有线程安全问题）

4、执行子线程逻辑

5、删除子线程新增的TTL,将备份还原重新设置到子线程的TTL中

TTL的原理：

主要通过TTL提供的TtlRunnable或者TtlCallable包装器来完成的。
在使用包装器包装一个Runnable或Callable任务时，包装器会以快照的方式捕获当前线程的ThreadLocal状态，并在任务实际执行时，将这些状态复制到执行任务的线程中去。
任务执行完毕后，再将执行线程中的ThreadLocal状态恢复到原始状态，以避免潜在的内存泄漏或数据污染问题。

注意：

TTL为什么不直接继承ThreadLocal？

有些业务需要用到ITL特性，如果直接继承ThreadLocal，就会丢失ITL的父拷贝到子线程数据的特性(子线程创建时拷贝)

为什么需要在run执行完之后调用restore()？

restore里面会主动调用remove()回收，避免内存泄露（会删除子线程新增的TTL）不调用restore()的话，就会覆盖之前backup备份部分子线程的数据，这样可能在业务上有隐患

TTL存在线程安全问题？

存在的，
1、因为默认都是引用类型拷贝，就是浅拷贝，只会复制对象的引用而不复制对象本身
2、如果存储在TTL中的数据是可变的引用类型（如List、Map等），那么当子线程通过这些引用修改了共享对象的状态时，这些修改是对所有持有该引用的线程可见的。
3、所以，如果子线程修改了数据，主线程是可以感知到的；也就是说，如果子线程和父线程（或者其他子线程）共享了这些可变的引用类型的数据，且都对数据进行了修改，就可能会出现线程安全问题
解决：
1、如果TTL中存储的数据是可变的，应该提供数据的深拷贝（deep copy）机制，这样每个线程都会拥有数据的独立副本，互不影响。
或者，对于共享的可变数据，需要使用适当的同步机制（如使用synchronized关键字或者java.util.concurrent包下的线程安全数据结构）来确保线程安全。
2、另一种方法是尽量在TTL中存储不可变的数据，这样即使数据是通过引用传递，由于数据本身不可变，也不会存在线程安全问题。

TTL是否存在内存泄露问题？

TTL维护的holder本身是一个static，使用的时候会调用restore(),然后里面显式调用remove()清除子线程新增TTL，所以正确使用下是没有内存泄露问题的

另类解决之道

透传的数据

package com.ry.learning.study.Threadpool;
import java.util.HashMap;
public class Context_ {
    public static volatile ThreadLocal<String> LOCAL = new ThreadLocal<String>() {
        @Override
        protected String initialValue() {
            LOCAL.set("2003-2023");
            return "cantop";
        }
    };
    private static String s;
    private static String rId;
    static HashMap<Integer, Integer> map = new HashMap<>();
    public static String getTraceAttr(String s) {
        return LOCAL.get();
    }
    public static void setTraceAttr(String s) {
        LOCAL.set(s);
    }
    public static void clearTraceAttrs() {
        LOCAL.remove();
    }
    @Override
    public String toString() {
        return "Context_{" + "}";
    }
}

package com.ry.learning.study.Threadpool;
public class LocalHolder {
    public static volatile ThreadLocal<String> TREAD_LOCAL = new ThreadLocal(){
        @Override
        protected String initialValue() {
            TREAD_LOCAL.set("2023-11-17");
            return "YES";
        }
    };
    private static volatile ThreadLocal<String> T_L = new ThreadLocal<>();
    public static String getClientInfo() {
        return TREAD_LOCAL.get();
    }
    public static void setClientInfo(String clientInfo) {
        TREAD_LOCAL.set(clientInfo);
    }

    public static void clean(){
        TREAD_LOCAL.remove();
        T_L.remove();
    }
}

创建线程池

package com.ry.learning.study.Threadpool;
import lombok.NonNull;
import org.slf4j.MDC;
import java.util.Map;
import java.util.concurrent.*;

/*
 这个的思路就不再是传递数据了,而是获取数据设置数据，每个父线程数据的时候子线程也会有对应的数据
*/
public class EventThreadPool_ extends ThreadPoolExecutor {

    public EventThreadPool_(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }
    public EventThreadPool_(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
    }
    public EventThreadPool_(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
    }
    public EventThreadPool_(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
    }


    @Override
    public void execute(@NonNull final Runnable command) {
      //只拿需要的参数进行传递
        //getTraceAttr    getClientInfo  就都是获取主线程中各个类的 ThreadLocal 中的数据的，所以内部是各个类内的ThreadLocal 的对象get的操作
        String reqId = Context_.getTraceAttr("X-API-Request-Id");
        String clientInfo = LocalHolder.getClientInfo();
// .....可以进行扩展
      
        // 获取父线程MDC中的内容，必须在run方法之前，否则等异步线程执行的时候有可能MDC里面的值已经被清空了，这个时候就会返回null
       // Map<String, String> context = MDC.getCopyOfContextMap();
        Runnable task = new Runnable() {
            @Override
            public void run() {
                //设置给子线程对应的数据的操作  
                Context_.setTraceAttr(reqId);
                // 将父线程的MDC内容传给子线程
                // MDC.setContextMap(context);
                LocalHolder.setClientInfo(clientInfo);
// .....可以进行扩展
              
                try {
                    command.run();
                } catch (Exception e) {
                    System.out.println("EventThreadPool_ error" + e);
                } finally {
                    //为防止全链路请求ID污染，这里需清理
                //    Context_.clearTraceAttrs();
                    LocalHolder.clean();
                    // 清空MDC内容
                    //MDC.clear();
                }
            }
        };
        super.execute(task);
    }
}

测试的类

package com.ry.learning.study.Threadpool;
import java.util.concurrent.*;

public class ThreadPool_T {
    static EventThreadPool_ pool = new EventThreadPool_(3, 3, 1,TimeUnit.MICROSECONDS,new ArrayBlockingQueue<>(100), new ThreadPoolExecutor.DiscardPolicy());
    public static void main(String[] args) {
      
      
       pool.execute(()->{
            System.out.println("线程1-Context_："+ Thread.currentThread().getName()+"\t"+Context_.LOCAL.get().toString());
            System.out.println("线程1-LocalHolder："+ Thread.currentThread().getName()+"\t"+LocalHolder.TREAD_LOCAL.get().toString());
        });
      
      
        LocalHolder.TREAD_LOCAL.set("ry");
        Context_.LOCAL.set("ry");
        pool.execute(()->{
            System.out.println("线程1-Context_："+ Thread.currentThread().getName()+"\t"+Context_.LOCAL.get().toString());
            System.out.println("线程1-LocalHolder："+ Thread.currentThread().getName()+"\t"+LocalHolder.TREAD_LOCAL.get().toString());
        });
      
        LocalHolder.TREAD_LOCAL.set("rycantop");
        Context_.LOCAL.set("rycantop");
        pool.execute(()->{
            LocalHolder.TREAD_LOCAL.set("rycan");
            Context_.LOCAL.set("rycan");
            System.out.println("线程2-Context_："+ Thread.currentThread().getName()+"\t"+Context_.LOCAL.get().toString());
            System.out.println("线程2-LocalHolder："+ Thread.currentThread().getName()+"\t"+LocalHolder.TREAD_LOCAL.get().toString());
        });

        pool.execute(()->{
            System.out.println("线程3-Context_："+ Thread.currentThread().getName()+"\t"+Context_.LOCAL.get().toString());
            System.out.println("线程3-LocalHolder："+ Thread.currentThread().getName()+"\t"+LocalHolder.TREAD_LOCAL.get().toString());
        });
        pool.shutdown();

    }
}

线程1-Context_：pool-1-thread-1	cantop
线程1-LocalHolder：pool-1-thread-1	YES
线程1-Context_：pool-1-thread-2	ry
线程1-LocalHolder：pool-1-thread-2	ry
线程2-Context_：pool-1-thread-3	rycan
线程2-LocalHolder：pool-1-thread-3	rycan
线程3-Context_：pool-1-thread-1	rycantop
线程3-LocalHolder：pool-1-thread-1	rycantop