JUC第六讲：ThreadLocal/InheritableThreadLocal详解/TTL-MDC日志上下文实践-阿里云开发者社区

1、ThreadLocal是什么？有哪些用途？

1.1、ThreadLocal的定义

这个类提供了线程局部变量，能使线程中的某个值与保存值的对象关联起来，例如：threadLocal.set(5)，会将“threadLocal”和“5”作为键值对保存在该线程的threadLocals里。ThreadLocal提供了get与set等访问接口或方法，这些方法为每个使用该变量的线程都存有一份独立的副本（即每个线程的 threadLocals 属性），因此get操作总是返回由当前执行线程在调用set时设置的最新值。
只要线程处于活动状态并且Threadocal实例可以访问，每个线程就拥有对其线程局部变量副本的隐式引用；在一个线程消失之后，线程本地实例的所有副本都会被垃圾收集（除非存在对这些副本的其他引用）。

// hash code
private final int threadLocalHashCode = nextHashCode();
// AtomicInteger类型，从0开始
private static AtomicInteger nextHashCode =
    new AtomicInteger();
// hash code每次增加 1640531527 
private static final int HASH_INCREMENT = 0x61c88647;
// 下一个hash code
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

从上面的定义可以知道，ThreadLocal 的 hashcode（threadLocalHashCode）是从0开始，每新建一个 ThreadLocal，对应的 hashcode就加0x61c88647

1.2、ThreadLocal 作用

ThreadLocal的作用是提供线程内的局部变量，这种变量在多线程环境下访问时能够保证各个线程里变量的独立性。
使用Demo

public class ThreadLocalDemo {
    public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>();
    public static ThreadLocal<User> threadLocalUser = new ThreadLocal<User>();
    public static void main(String args[]) {
        threadLocal.set(100); // 保存值
        System.out.println(threadLocal.get());  // 获取值
        User user = new User();
        user.setName("jet_qi");
        user.setAge(29);
        threadLocalUser.set(user);  // 保存值
        System.out.println(threadLocalUser.get());  // 获取值
        // todo 需要执行remove操作
    }
    static class User{
        String name;
        Integer age;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public Integer getAge() {
            return age;
        }
        public void setAge(Integer age) {
            this.age = age;
        }
        @Override
        public String toString() {
            return "User [name=" + name + ", age=" + age + "]";
        }
    }
}
// 输出结果
// 100
// User [name=jet_qi, age=25]

使用场景

1、处理重复提交拦截
2、在Spring切面编程中的使用，将前置逻辑中获取到的数据放入ThreadLocal中，然后在后置处理逻辑中作为入参传入，最后在finally语句中执行remove操作，防止内存泄漏。

1.3、ThreadLocalMap 的定义

ThreadLocalMap 是一个自定义哈希映射，仅用于维护线程本地变量值。ThreadLocalMap是ThreadLocal的内部类，主要有一个Entry数组，Entry的key为ThreadLocal，value为ThreadLocal对应的值。每个线程都有一个ThreadLocalMap类型的threadLocals变量。

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

1.4、set() 方法

1、先拿到当前线程，再使用getMap方法拿到当前线程的 threadLocals 变量
2、如果 threadLocals 不为空，则将当前ThreadLocal作为key，传入的值作为value，调用set方法（见下文代码块1详解）插入threadLocals。
3、如果threadLocals为空则调用创建一个ThreadLocalMap，并新建一个Entry放入该ThreadLocalMap, 调用set方法的ThreadLocal和传入的value作为该Entry的key和value

注意此处的threadLocals变量是一个ThreadLocalMap，是Thread的一个局部变量，因此它只与当前线程绑定。

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t); // 获取当前线程的ThreadLocalMap
    // 当前线程的ThreadLocalMap不为空则调用set方法, this为调用该方法的ThreadLocal对象
    if (map != null) 
        map.set(this, value);
    // map为空则调用createMap方法创建一个新的ThreadLocalMap, 并新建一个Entry放入该
    // ThreadLocalMap, 调用set方法的ThreadLocal和传入的value作为该Entry的key和value
    else
        createMap(t, value);    
}
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;  // 返回线程t的threadLocals属性
}

代码块1：set方法

private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);  // 计算出索引的位置
    // 从索引位置开始遍历,由于不是链表结构, 因此通过nextIndex方法来寻找下一个索引位置  
    for (Entry e = tab[i];
         e != null; // 当遍历到的Entry为空时结束遍历
         e = tab[i = nextIndex(i, len)]) {  
        ThreadLocal<?> k = e.get(); // 拿到Entry的key，也就是ThreadLocal  
        // 该Entry的key和传入的key相等, 则用传入的value替换掉原来的value  
        if (k == key) {
            e.value = value;
            return;
        }
        // 该Entry的key为空, 则代表该Entry需要被清空, 
        // 调用replaceStaleEntry方法  
        if (k == null) {
          // 该方法会继续寻找传入key的安放位置, 并清理掉key为空的Entry  
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    // 寻找到一个空位置,　则放置在该位置上
    tab[i] = new Entry(key, value);
    int sz = ++size;
    // cleanSomeSlots是用来清理掉key为空的Entry,如果此方法返回true,则代表至少清理
    // 了1个元素, 则此次set必然不需要扩容, 如果此方法返回false则判断sz是否大于阈值
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();   // 扩容
}

1、通过传入的key的hashCode计算出索引的位置
2、从索引位置开始遍历，由于不是链表结构，因此通过nextIndex方法来寻找下一个索引位置
3、如果找到某个Entry的key和传入的key相同，则用传入的value替换掉该Entry的value。
4、如果遍历到某个Entry的key为空，则调用replaceStaleEntry方法（见下文代码块2详解）
5、如果通过nextIndex寻找到一个空位置（代表没有找到key相同的），则将元素放在该位置上
6、调用cleanSomeSlots方法清理key为null的Entry，并判断是否需要扩容，如果需要则调用rehash方法进行扩容（见下文rehash方法详解）。

代码块2：replaceStaleEntry方法

private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                               int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;
    int slotToExpunge = staleSlot;  // 清除元素的开始位置（记录索引位置最前面的）
    // 向前遍历，直到遇到Entry为空
    for (int i = prevIndex(staleSlot, len); 
         (e = tab[i]) != null;
         i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;  // 记录最后一个key为null的索引位置
    // Find either the key or trailing null slot of run, whichever
    // occurs first
    for (int i = nextIndex(staleSlot, len); // 向后遍历，直到遇到Entry为空
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        // 该Entry的key和传入的key相等, 则将传入的value替换掉该Entry的value
        if (k == key) {
            e.value = value;
            // 将i位置和staleSlot位置的元素对换（staleSlot位置较前，是要清除的元素）
            tab[i] = tab[staleSlot];  
            tab[staleSlot] = e;
            // 如果相等, 则代表上面的向前寻找key为null的遍历没有找到，
            // 即staleSlot位置前面的元素没有需要清除的，此时将slotToExpunge设置为i, 
            // 因为原staleSlot的元素已经被放到i位置了，这时位置i前面的元素都不需要清除
            if (slotToExpunge == staleSlot) 
                slotToExpunge = i;
            // 从slotToExpunge位置开始清除key为空的Entry
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }
        // 如果第一次遍历到key为null的元素，并且上面的向前寻找key为null的遍历没有找到，
        // 则将slotToExpunge设置为当前的位置
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }
    // 如果key没有找到，则新建一个Entry，放在staleSlot位置
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);
    // 如果slotToExpunge!=staleSlot，代表除了staleSlot位置还有其他位置的元素需要清除
    // 需要清除的定义：key为null的Entry，调用cleanSomeSlots方法清除key为null的Entry
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

1、slotToExpunge始终记录着需要清除的元素的最前面的位置（即slotToExpunge前面的元素是不需要清除的）
2、从位置staleSlot向前遍历，直到遇到Entry为空，用staleSlot记录最后一个key为null的索引位置（也就是遍历过位置最前的key为null的位置）
3、从位置staleSlot向后遍历，直到遇到Entry为空，如果遍历到key和入参key相同的，则将入参的value替换掉该Entry的value，并将i位置和staleSlot位置的元素对换（staleSlot位置较前，是要清除的元素），遍历的时候判断slotToExpunge的值是否需要调整，最后调用expungeStaleEntry方法（见下文expungeStaleEntry方法详解）和cleanSomeSlots方法（见下文代码块3详解）清除key为null的元素。
4、如果key没有找到，则使用入参的key和value新建一个Entry，放在staleSlot位置
5、判断是否还有其他位置的元素key为null，如果有则调用expungeStaleEntry方法和cleanSomeSlots方法清除key为null的元素

代码块3：cleanSomeSlots方法

private boolean cleanSomeSlots(int i, int n) {
    boolean removed = false;
    Entry[] tab = table;
    int len = tab.length;
    do {
        i = nextIndex(i, len);  // 下一个索引位置
        Entry e = tab[i];
        if (e != null && e.get() == null) { // 遍历到key为null的元素
            n = len;  // 重置n的值
            removed = true; // 标志有移除元素
            i = expungeStaleEntry(i); // 移除i位置及之后的key为null的元素
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}

从 i 开始，清除key为空的Entry，遍历次数由当前的table长度决定，当遍历到一个key为null的元素时，调用expungeStaleEntry清除，并将遍历次数重置。至于为什么使用table长度来决定遍历次数，官方给出的解释是这个方法简单、快速，并且效果不错。

1.5、get() 方法

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        // 调用getEntry方法, 通过this（调用get()方法的ThreadLocal）获取对应的Entry
        ThreadLocalMap.Entry e = map.getEntry(this);
        // Entry不为空则代表找到目标Entry, 返回该Entry的value值
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 该线程的ThreadLocalMap为空，或者没有找到目标Entry，则调用setInitialValue方法
    return setInitialValue();
}

跟set方法差不多，先拿到当前的线程，再使用getMap方法拿到当前线程的threadLocals变量
如果threadLocals不为空，则将调用get方法的ThreadLocal作为key，调用getEntry方法（见下文代码块5详解）找到对应的Entry。
如果threadLocals为空或者找不到目标Entry，则调用setInitialValue方法（见下文代码块4详解）进行初始化。
代码块4：setInitialValue方法

private T setInitialValue() {
    T value = initialValue(); // 默认null，需要用户自己重写该方法，
    Thread t = Thread.currentThread();  // 当前线程
    ThreadLocalMap map = getMap(t); // 拿到当前线程的threadLocals
    // threadLocals不为空则将当前的ThreadLocal作为key，null作为value，插入到ThreadLocalMap
    if (map != null)  
        map.set(this, value);
    // threadLocals为空则调用创建一个ThreadLocalMap，并新建一个Entry放入该ThreadLocalMap, 
    // 调用set方法的ThreadLocal和value作为该Entry的key和value
    else
        createMap(t, value);
    return value;
}

1、如果是threadLocals为空，创建一个新的ThreadLocalMap，并将当前的ThreadLocal作为key，null作为value，插入到新创建的ThreadLocalMap，并返回null。
2、如果threadLocals不为空，则将当前的ThreadLocal作为key，null作为value，插入到threadLocals。
3、注意上面的 initialValue()方法为protected，如果希望线程局部变量具有非null的初始值，则必须对ThreadLocal进行子类化，并重写此方法。

代码块5：getEntry方法

private Entry getEntry(ThreadLocal<?> key) {
  //根据hash code计算出索引位置 
    int i = key.threadLocalHashCode & (table.length - 1);    
    Entry e = table[i];
    // 如果该Entry的key和传入的key相等, 则为目标Entry, 直接返回
    if (e != null && e.get() == key)    
        return e;
    // 否则，e不是目标Entry, 则从e之后继续寻找目标Entry
    else
        return getEntryAfterMiss(key, i, e);
}

1、根据hash code计算出索引位置
2、如果该索引位置Entry的key和传入的key相等，则为目标Entry，直接返回
3、否则，e不是目标Entry，调用getEntryAfterMiss方法（见下文代码块6详解）继续遍历。

代码块6：getEntryAfterMiss方法

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;
    while (e != null) {
        ThreadLocal<?> k = e.get();
        // 找到目标Entry，直接返回
        if (k == key)  
            return e;
        // 调用expungeStaleEntry清除key为null的元素
        if (k == null)
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);  // 下一个索引位置
        e = tab[i]; // 下一个遍历的Entry
    }
    return null;    // 找不到, 返回空
}

从元素e开始向后遍历，如果找到目标Entry元素直接返回；如果遇到key为null的元素，调用expungeStaleEntry方法（见下文 expungeStaleEntry 方法详解）进行清除；否则，遍历到 Entry 为 null 时，结束遍历，返回 null。

1.6、remove() 方法

public void remove() {
  // 获取当前线程的ThreadLocalMap 
  ThreadLocalMap m = getMap(Thread.currentThread()); 
  if (m != null)
    m.remove(this);    // 调用此方法的ThreadLocal作为入参，调用remove方法  
 }
private void remove(ThreadLocal<?> key) {
    Entry[] tab = table;
    int len = tab.length;
    // 根据hashCode计算出当前ThreadLocal的索引位置
    int i = key.threadLocalHashCode & (len-1);  
    // 从位置i开始遍历，直到Entry为null
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        if (e.get() == key) {   // 如果找到key相同的
            e.clear();  // 则调用clear方法, 该方法会把key的引用清空
            expungeStaleEntry(i);//调用expungeStaleEntry方法清除key为null的Entry
            return;
        }
    }
}

方法很简单，拿到当前线程的threadLocals属性，如果不为空，则将key为当前ThreadLocal的键值对移除，并且会调用expungeStaleEntry方法清除key为空的Entry。

1.7、expungeStaleEntry 方法

清除key为空的Entry

// 从staleSlot开始, 清除key为空的Entry, 并将不为空的元素放到合适的位置，最后返回Entry为空的位置
private int expungeStaleEntry(int staleSlot) {  
    Entry[] tab = table;
    int len = tab.length;
    // expunge entry at staleSlot
    tab[staleSlot].value = null;    // 将tab上staleSlot位置的对象清空
    tab[staleSlot] = null;
    size--;
    // Rehash until we encounter null
    Entry e;
    int i;
    for (i = nextIndex(staleSlot, len); // 遍历下一个元素, 即(i+1)%len位置的元素
         (e = tab[i]) != null;  // 遍历到Entry为空时, 跳出循环并返回索引位置
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get(); 
        if (k == null) {    // 当前遍历Entry的key为空, 则将该位置的对象清空
            e.value = null;
            tab[i] = null;
            size--;
        } else { // 当前遍历Entry的key不为空
            int h = k.threadLocalHashCode & (len - 1);  // 重新计算该Entry的索引位置
            if (h != i) {   // 如果索引位置不为当前索引位置i
                tab[i] = null;  // 则将i位置对象清空, 替当前Entry寻找正确的位置
                // 如果h位置不为null，则向后寻找当前Entry的位置
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;   
}

源码解读：从staleSlot开始，清除key为null的Entry，并将不为空的元素放到合适的位置，最后遍历到Entry为空的元素时，跳出循环返回当前索引位置。
注意：set、get、remove方法，在遍历的时候如果遇到key为null的情况，都会调用expungeStaleEntry方法来清除key为null的Entry。

1.8、rehash 方法

private void rehash() {
    expungeStaleEntries();  // 调用expungeStaleEntries方法清理key为空的Entry
    // 如果清理后size超过阈值的3/4, 则进行扩容
    if (size >= threshold - threshold / 4)  
        resize();
}
/**
 * Double the capacity of the table.
 */
private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;  // 新表长度为老表2倍
    Entry[] newTab = new Entry[newLen]; // 创建新表
    int count = 0;
    for (int j = 0; j < oldLen; ++j) {  // 遍历所有元素
        Entry e = oldTab[j];  // 拿到对应位置的Entry
        if (e != null) {
            ThreadLocal<?> k = e.get();
            if (k == null) {  // 如果key为null，将value清空
                e.value = null; // Help the GC
            } else {
              // 通过hash code计算新表的索引位置
                int h = k.threadLocalHashCode & (newLen - 1);
                // 如果新表的该位置已经有元素，则调用nextIndex方法直到寻找到空位置
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;  // 将元素放在对应位置
                count++;
            }
        }
    }
    setThreshold(newLen); // 设置新表扩容的阈值
    size = count; // 更新size
    table = newTab; // table指向新表
}

1、调用expungeStaleEntries方法（该方法和expungeStaleEntry类似，只是把搜索范围扩大到整个表）清理key为空的Entry
2、如果清理后size超过阈值的3/4，则进行扩容。
3、新表长度为老表2倍，创建新表。
4、遍历老表所有元素，如果key为null，将value清空；否则通过hash code计算新表的索引位置h，如果h已经有元素，则调用nextIndex方法直到寻找到空位置，将元素放在新表的对应位置。
5、设置新表扩容的阈值、更新size、table指向新表。

1.9、功能测试

public class TestThreadLocal {
    public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>();
  // 主线程
    public static void main(String args[]) throws InterruptedException {
        Thread threadOne = new ThreadOne(); // 线程1
        Thread threadTwo = new ThreadTwo(); // 线程2
        threadTwo.start(); // 线程2开始执行
        TimeUnit.MILLISECONDS.sleep(100); // 睡眠, 以等待线程2执行完毕
        threadOne.start(); // 线程1开始执行
        TimeUnit.MILLISECONDS.sleep(100); // 睡眠, 以等待线程1执行完毕
        // 此时线程1和线程2都已经设置过值, 此处输出为空, 说明子线程与父线程之间也是互不影响的
        System.out.println("main: " + threadLocal.get());
    }
    /* 线程1 */
    private static class ThreadOne extends Thread {
        @Override
        public void run() {
            // 此时线程2已经调用过set(456), 此处输出为空, 说明线程之间是互不影响的
            System.out.println("ThreadOne: " + threadLocal.get());
            threadLocal.set(123);
            System.out.println("ThreadOne: " + threadLocal.get());
        }
    }
    /* 线程2 */
    private static class ThreadTwo extends Thread {
        @Override
        public void run() {
            threadLocal.set(456); // 设置当前ThreadLocal的值为456
            System.out.println("ThreadTo: " + threadLocal.get());
        }
    }
}

输出结果：

ThreadTo: 456
ThreadOne: null
ThreadOne: 123
main: null

从输出结果可以看出，线程1、线程2和主线程之间是彼此互不影响的。

2、ThreadLocal 内存泄漏问题

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

从上面源码可以看出，ThreadLocalMap使用ThreadLocal的弱引用作为 Entry 的 key，如果一个 ThreadLocal 没有外部强引用来引用它，下一次系统GC时，这个 ThreadLocal 必然会被回收，这样一来，ThreadLocalMap 中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value。
我们上面介绍的get、set、remove等方法中，都会对key为null的Entry进行清除（expungeStaleEntry方法，将Entry的value清空，等下一次垃圾回收时，这些Entry将会被彻底回收）。
但是如果当前线程一直在运行，并且一直不执行get、set、remove方法，这些key为null的Entry的value就会一直存在一条强引用链：Thread Ref -> Thread -> ThreadLocalMap -> Entry -> value，导致这些key为null的Entry的value永远无法回收，造成内存泄漏。

内存泄漏的条件：

ThreadLocal 总结了使用ThreadLocal时会发生内存泄漏的前提条件：

①ThreadLocal引用被设置为null，且后面没有set，get，remove操作；
②线程一直运行，不停止；
③触发了垃圾回收（Minor GC或Full GC）

使用ThreadLocal时遵守以下两个小原则:

①ThreadLocal申明为private static final。

private与final 尽可能不让他人修改变更引用，static 表示为类属性，只有在程序结束才会被回收。

②ThreadLocal使用后务必调用remove方法。

最简单有效的方法是使用后将其移除。

如何避免内存泄漏？

为了避免这种情况，我们可以在使用完ThreadLocal后，手动调用remove方法，以避免出现内存泄漏。

3、ThreadLocal 总结

总结：

每个线程都有一个ThreadLocalMap 类型的 threadLocals 属性。
ThreadLocalMap 类相当于一个Map，key 是 ThreadLocal 本身，value 就是我们的值。
当我们通过 threadLocal.set(new Integer(123)); ，我们就会在这个线程中的 threadLocals 属性中放入一个键值对，key 是这个 threadLocal.set(new Integer(123))的 threadlocal，value 就是值new Integer(123)。
当我们通过 threadlocal.get() 方法的时候，首先会根据这个线程得到这个线程的 threadLocals 属性，然后由于这个属性放的是键值对，我们就可以根据键 threadlocal 拿到值。注意，这时候这个键 threadlocal 和我们 set 方法的时候的那个键 threadlocal 是一样的，所以我们能够拿到相同的值。
ThreadLocalMap 的get/set/remove方法跟HashMap的内部实现都基本一样，通过 key.threadLocalHashCode & (table.length - 1) 运算式计算得到我们想要找的索引位置，如果该索引位置的键值对不是我们要找的，则通过nextIndex方法计算下一个索引位置，直到找到目标键值对或者为空。
hash冲突：在HashMap中相同索引位置的元素以链表形式保存在同一个索引位置；而在ThreadLocalMap中，没有使用链表的数据结构，而是将（当前的索引位置+1）对length取模的结果作为相同索引元素的位置：源码中的nextIndex方法，可以表达成如下公式：如果i为当前索引位置，则下一个索引位置 = (i + 1 < len) ? i + 1 : 0。

4、InheritableThreadLocal 详解

InheritableThreadLocal是ThreadLocal的子类

4.1、定义

InheritableThreadLocal 继承了ThreadLocal，此类扩展了ThreadLocal以提供从父线程到子线程的值的继承：当创建子线程时，子线程接收父线程具有的所有可继承线程局部变量的初始值。通常子线程的值与父线程的值是一致的。但是，通过重写此类中的childValue方法，可以将子线程的值作为父线程的任意函数。

4.2、源码

InheritableThreadLocal的源码很短，只有3个很短的方法，我们主要关注getMap()方法和creatMap()方法，这两个方法都是重写的，跟ThreadLocal中的差别在于把ThreadLocal中的threadLocals换成了inheritableThreadLocals，这两个变量都是ThreadLocalMap类型，并且都是Thread类的属性。

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    /**
     * Computes the child's initial value for this inheritable thread-local
     * variable as a function of the parent's value at the time the child
     * thread is created.  This method is called from within the parent
     * thread before the child is started.
     * <p>
     * This method merely returns its input argument, and should be overridden
     * if a different behavior is desired.
     *
     * @param parentValue the parent thread's value
     * @return the child thread's initial value
     */
    protected T childValue(T parentValue) {
        return parentValue;
    }
    /**
     * Get the map associated with a ThreadLocal.
     *
     * @param t the current thread
     */
    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }
    /**
     * Create the map associated with a ThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the table.
     */
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

/* ThreadLocal values pertaining to this thread. This map is maintained
 * by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
/*
 * InheritableThreadLocal values pertaining to this thread. This map is
 * maintained by the InheritableThreadLocal class.
 */
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

4.3、InheritableThreadLocal 继承父线程的值

上文的定义说道了InheritableThreadLocal会继承父线程的值，这是InheritableThreadLocal被创造出来的意义，具体是怎么实现的？

让我们从子线程被创建出来开始看起

public Thread() {
    init(null, null, "Thread-" + nextThreadNum(), 0);
}
private void init(ThreadGroup g, Runnable target, String name, long stackSize) {
    init(g, target, name, stackSize, null);
}
private void init(ThreadGroup g, Runnable target, String name,
        long stackSize, AccessControlContext acc) {
  // ... 省略掉一部分代码
  if (parent.inheritableThreadLocals != null)
    this.inheritableThreadLocals =
        ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    // ... 省略掉一部分代码
}
static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
    return new ThreadLocalMap(parentMap);
}
/**
 * Construct a new map including all Inheritable ThreadLocals
 * from given parent map. Called only by createInheritedMap.
 *
 * @param parentMap the map associated with parent thread.
 */
private ThreadLocalMap(ThreadLocalMap parentMap) {
    Entry[] parentTable = parentMap.table;
    int len = parentTable.length;
    setThreshold(len);
    table = new Entry[len];// 创建跟父线程相同大小的table
    for (int j = 0; j < len; j++) {// 遍历父线程的inheritableThreadLocals, 在上面第3个代码块作为参数传下来
        Entry e = parentTable[j];
        if (e != null) {
            @SuppressWarnings("unchecked")
            ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();// 拿到每个键值对的key, 即ThreadLocal对象
            if (key != null) {
                Object value = key.childValue(e.value);// 此处会调用InheritableThreadLocal重写的方法, 默认直接返回入参值
                Entry c = new Entry(key, value);// 使用key和value构造一个Entry
                int h = key.threadLocalHashCode & (len - 1);// 通过位与运算找到索引位置
                while (table[h] != null)// 如果该索引位置已经被占,则寻找下一个索引位置
                    h = nextIndex(h, len);
                table[h] = c;// 将Entry放在对应的位置
                size++;
            }
        }
    }
}

这是线程被创建的整个流程，从第3个代码块我们可以知道当父线程的inheritableThreadLocals不为空时，当前线程的inheritableThreadLocals属性值会被直接创建，并被赋予跟父线程的inheritableThreadLocals属性一样的值，从最后一个代码块看出来(已在代码中做详细注释)。
此时我们知道了，当一个子线程创建的时候，会把父线程的inheritableThreadLocals属性的值继承到自己的inheritableThreadLocals属性。那么现在的问题是父线程的inheritableThreadLocals属性会有值吗？因为上文提到的ThreadLocal中，我们知道set()方法时，是把键值对放在threadLocals属性。这就要提到刚才说的InheritableThreadLocal重写的getMap()方法，因为InheritableThreadLocal类的set()和get()方法都是用的父类即ThreadLocal的方法，而从ThreadLocal的源码中我们知道，ThreadLocal的get()、set()、remove()方法都会先调用getMap()方法，而InheritableThreadLocal重写了该方法，因此此时返回的ThreadLocalMap为inheritableThreadLocals，所以我们知道了，当定义为InheritableThreadLocal时，操作的属性为inheritableThreadLocals而不是threadLocals。

/**
 * Get the map associated with a ThreadLocal.
 *
 * @param t the current thread
 */
ThreadLocalMap getMap(Thread t) {
   return t.inheritableThreadLocals;
}

4.4、功能测试

下面代码是对 InheritableThreadLocal 继承父线程的值的验证，可以看出，子线程确实拿到了父线程的值。

4.5、InheritableThreadLocal 变量的可见性探讨

package com.chillax.test;
import java.util.concurrent.TimeUnit;
/**
 * InheritableThreadLocal可见性测试
 * 
 * @author JoonWhee
 * @author http://blog.csdn.net/v123411739
 * @Date 2017年12月2日
 */
public class TestInheritableThreadLocal2 {
    public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>();
    public static ThreadLocal<Integer> inheritableThreadLocal = new InheritableThreadLocal<Integer>();
    public static ThreadLocal<User> mutableInheritableThreadLocal = new InheritableThreadLocal<User>();
    public static ThreadLocal<User> mutableInheritableThreadLocalTo = new InheritableThreadLocal<User>();
    public static ThreadLocal<String> immutableInheritableThreadLocal = new InheritableThreadLocal<String>();
    public static ThreadLocal<String> immutableInheritableThreadLocalTo = new InheritableThreadLocal<String>();
    public static void main(String args[]) throws InterruptedException {
        // 测试0.ThreadLocal普通测试;
        // 结论0: ThreadLocal下子线程获取不到父线程的值
        threadLocal.set(new Integer(123)); // 父线程初始化
        Thread thread = new MyThread();
        thread.start();
        TimeUnit.MILLISECONDS.sleep(100); // 睡眠, 以等待子线程执行完毕
        System.out.println("main = " + threadLocal.get());
        System.out.println();
        // 测试1.InheritableThreadLocal普通测试;
        // 结论1: InheritableThreadLocal下子线程可以获取父线程的值
        inheritableThreadLocal.set(new Integer(123)); // 父线程初始化
        Thread threads = new MyThreadTo();
        threads.start();
        TimeUnit.MILLISECONDS.sleep(100); // 睡眠, 以等待子线程执行完毕
        System.out.println("main = " + inheritableThreadLocal.get());
        System.out.println();
        // 测试2.父线程和子线程的传递关系测试: 可变对象, 父线程初始化;
        // 结论2: 父线程初始化, Thread Construct浅拷贝, 共用索引, 子线程先get()对象, 再修改对象的属性,
        // 父线程跟着变, 注意: 此处子线程如果没有先get()直接使用set()一个新对象, 父线程是不会跟着变的
        mutableInheritableThreadLocal.set(new User("joon"));// 2.1父线程初始化
        Thread TestThread = new TestThread(); // 2.2先初始化父线程再创建子线程, 确保子线程能继承到父线程的User
        TestThread.start(); // 开始执行子进程
        TimeUnit.MILLISECONDS.sleep(100); // 睡眠, 以等待子线程执行完毕
        System.out.println("main = " + mutableInheritableThreadLocal.get()); // 2.5此处输出值为子线程修改的值, 因此可得出上述结论2
        System.out.println();
        // 测试3.父线程和子线程的传递关系测试: 可变对象, 父线程不初始化;
        // 结论3: 父线程没有初始化, 子线程初始化, 无Thread Construct浅拷贝, 子线程和主线程都是单独引用, 不同对象,
        // 子线程修改父线程不跟着变
        Thread TestThreadTo = new TestThreadTo(); // 3.1创建子进程
        TestThreadTo.start();
        TimeUnit.MILLISECONDS.sleep(100); // 睡眠, 以等待子线程执行完毕
        System.out.println("main = " + mutableInheritableThreadLocalTo.get()); // 3.3此处输出为null, 可得出上述结论3
        System.out.println();
        // 测试4.父线程和子线程的传递关系测试: 不可变对象, 父线程初始化;
        // 结论4: 父线程初始化, Thread Construct浅拷贝, 但由于不可变对象由于每次都是新对象, 所以互不影响
        immutableInheritableThreadLocal.set("joon");// 4.1父线程初始化
        Thread TestThreadTre = new TestThreadTre(); // 4.2先初始化父线程再创建子线程, 确保子线程能继承到父线程的值
        TestThreadTre.start(); // 执行子进程
        TimeUnit.MILLISECONDS.sleep(100); // 睡眠, 以等待子线程执行完毕
        System.out.println("main = " + immutableInheritableThreadLocal.get()); // 4.5此处输出为父线程的值, 因此可得出上述结论4
        System.out.println();
        // 测试5.父线程和子线程的传递关系测试: 不可变对象, 父线程不初始化;
        // 结论5: 父线程没有初始化, 子线程初始化, 无Thread Construct浅拷贝, 子线程和父线程操作不同对象, 互不影响
        Thread TestThreadFour = new TestThreadFour(); // 5.1创建子线程
        TestThreadFour.start();
        TimeUnit.MILLISECONDS.sleep(100); // 睡眠, 以等待子线程执行完毕
        System.out.println("main = " + immutableInheritableThreadLocalTo.get()); // 5.3此处输出为空, 因此可得出上述结论5
    }
    private static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("MyThread = " + threadLocal.get());
        }
    }
    private static class MyThreadTo extends Thread {
        @Override
        public void run() {
            System.out.println("inheritableThreadLocal = " + inheritableThreadLocal.get());
        }
    }
    private static class TestThread extends Thread {
        @Override
        public void run() {
            // 2.3此处输出父线程的初始化对象值, 代表子线程确实继承了父线程的对象值
            System.out.println("TestThread.before = " + mutableInheritableThreadLocal.get());
            // 2.4子类拿到对象并修改
            mutableInheritableThreadLocal.get().setName("whee");
            System.out.println("mutableInheritableThreadLocal = " + mutableInheritableThreadLocal.get());
        }
    }
    private static class TestThreadTo extends Thread {
        @Override
        public void run() {
            mutableInheritableThreadLocalTo.set(new User("whee"));// 3.2子线程调用set方法
            System.out.println("mutableInheritableThreadLocalTo = " + mutableInheritableThreadLocalTo.get());
        }
    }
    private static class TestThreadTre extends Thread {
        @Override
        public void run() {
            // 4.3此处输出父线程初始化的值, 代表子线程确实继承了父线程的对象值
            System.out.println("TestThreadTre.before = " + immutableInheritableThreadLocal.get());
            // 4.4子线程调用set方法
            immutableInheritableThreadLocal.set("whee");
            System.out.println("immutableInheritableThreadLocal = " + immutableInheritableThreadLocal.get());
        }
    }
    private static class TestThreadFour extends Thread {
        @Override
        public void run() {
            immutableInheritableThreadLocalTo.set("whee");// 5.2子线程调用set方法
            System.out.println("immutableInheritableThreadLocalTo = " + immutableInheritableThreadLocalTo.get());
        }
    }
    private static class User {
        String name;
        public User(String name) {
            this.name = name;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public String toString() {
            return "User [name=" + name + "]";
        }
    }
}

输出结果：

代码中都注释写清楚了，主要是根据存放可变对象 (User) 和不可变对象 (String)继续测试，根据输出结果可以得出以下结论：

1.对于可变对象：父线程初始化, 因为Thread Construct浅拷贝, 共用索引, 子线程修改父线程跟着变; 父线程不初始化, 子线程初始化, 无Thread Construct浅拷贝, 子线程和父线程都是单独引用, 不同对象, 子线程修改父线程不跟着变。

2.对于不可变对象：不可变对象由于每次都是新对象, 所以无论父线程初始化与否，子线程和父线程都互不影响。

从上面两条结论可知，子线程只能通过修改可变性（Mutable）对象对主线程才是可见的，即才能将修改传递给主线程，但这不是一种好的实践，不建议使用，为了保护线程的安全性，一般建议只传递不可变（Immuable）对象，即没有状态的对象。

虽然说不建议使用，但是有时候还是会碰到这种情况，如果想在修改子线程可变对象，同时不影响主线程，可以通过重写childValue()方法来实现。

4.6、重写childValue()方法实现子线程与父线程之间互不影响

package com.chillax.test;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
/**
 * 子线程与父线程实现完全互不影响
 */
public class TestInheritableThreadLocal3 {
    private static final ThreadLocal<Map<Object, Object>> testThreadLocal = new InheritableThreadLocal<Map<Object, Object>>();
    private static final ThreadLocal<Map<Object, Object>> threadLocal = new InheritableThreadLocalMap<Map<Object, Object>>();
    public static void main(String args[]) throws InterruptedException {
        // 下面的测试1在上文已经做过(上文的测试2), 此处拿出来是为了进行比较
        // 测试1: 可变对象, 父线程初始化, 子线程先获取对象再修改对象值
        // 结论1: 子线程可以通过先获取对象再修改的方式影响父线程的对象值 
        Map<Object, Object> map = new HashMap<>();
        map.put("aa", 123);
        testThreadLocal.set(map);   // 父线程进行初始化
        Thread testThreadone = new TestThread();   // 创建子线程
        testThreadone.start();
        TimeUnit.MILLISECONDS.sleep(100);   // 父线程睡眠, 以等待子线程执行完毕 
        System.out.println("main = " + testThreadLocal.get());  // 此处输出为子线程的值, 说明子线程影响父线程的对象值
        System.out.println();
        // 测试2: 可变对象, 父线程初始化, 子线程先获取对象再修改对象值
        // 结论2: 通过重写childValue()实现子线程与父线程的互不影响
        Map<Object, Object> mapTo = new HashMap<>();
        mapTo.put("aa", 123);
        threadLocal.set(mapTo);   // 父线程进行初始化
        Thread testThread = new TestThreadTo();   // 创建子线程
        testThread.start();
        TimeUnit.MILLISECONDS.sleep(100);   // 父线程睡眠, 以等待子线程执行完毕 
        System.out.println("main = " + threadLocal.get());  // 此处输出为父线程的值, 说明子线程与父线程已经互不影响
    }
    private static class TestThread extends Thread {
        @Override
        public void run() {
            // 此处输出父线程的初始化对象值, 代表子线程确实继承了父线程的对象值
            System.out.println("TestThread.before = " + testThreadLocal.get());
            // 子类拿到对象并修改
            testThreadLocal.get().put("aa", 456);
            System.out.println("testThreadLocal = " + testThreadLocal.get());
        }
    }
    private static class TestThreadTo extends Thread {
        @Override
        public void run() {
            // 此处输出父线程的初始化对象值, 代表子线程确实继承了父线程的对象值
            System.out.println("TestThreadTo.before = " + threadLocal.get());
            // 子类拿到对象并修改
            threadLocal.get().put("aa", 456);
            System.out.println("threadLocal = " + threadLocal.get());
        }
    }
    private static final class InheritableThreadLocalMap<T extends Map<Object, Object>>
            extends InheritableThreadLocal<Map<Object, Object>> {
        // 重写ThreadLocal中的方法
        protected Map<Object, Object> initialValue() {
            return new HashMap<Object, Object>();
        }
        // 重写InheritableThreadLocal中的方法
        protected Map<Object, Object> childValue(Map<Object, Object> parentValue) {
            if (parentValue != null) {
                // 返回浅拷贝, 以达到使子线程无法影响主线程的目的
                return (Map<Object, Object>) ((HashMap<Object, Object>) parentValue).clone();
            } else {
                return null;
            }
        }
    }
}

输出结果

TestThread.before = {aa=123}
testThreadLocal = {aa=456}
main = {aa=456}
TestThreadTo.before = {aa=123}
threadLocal = {aa=456}
main = {aa=123}

通过结果，我们可以看出重写childValue()方法确实可以达到使子线程与主线程互不影响的效果

5、TTL-MDC日志上下文实践

5.1、现状

zeye-trace-util

目前，公司使用的zeye-trace-util-1.0.10-RELEASE.jar，对MDC进行了自行包装，从源码分析，在使用MDC日志管理器的基础上，自行维护了一个ThreadLocal存储日志“traceId”。源码如下：

实际在日志系统内可见的是MDC输出的日志traceId，当我们使用TraceUtils获取时，一直使用的是本地ThreadLocal的traceId。MDC的Adapter使用了LogbackMDCAdapter进行适配，内部实现的也是一个ThreadLocal进行日志存放，源码如下：

ThreadLocal存在的问题

ThreadLocal能提供线程数据隔离，但是不能实现父子线程级别的数据传递。同时，JDK提供了InheritableThreadLocal类用于父子线程间的数据传递，原理即是在Thread初始化时进行父线程inheritableThreadLocals变量的拷贝，源码如下：
但是，我们在工作中常用的线程使用方式，都会按线程池进行包装，所以JDK提供的ThreadLocal不能支持线程池中线程执行时的父子线程数据传递的问题。所以，阿里TTL的解决方案孕育而来，详见：https://github.com/alibaba/transmittable-thread-local。原理即是，程序提供了TransmittableThreadLocal类用于上下文数据存储，并对原有Runnable、Callable或Task接口，进行修饰，替换其子类，在submit，fork时，对上下文数据copy，在执行真正的run方法。源码如下：
对于上下文父子线程数据Copy的过程，大概为，其内部存储了一个InheritableThreadLocal类型的holder，且使用WeakHashMap来进行弱指针引用，在run过程中会先进行上文Snapshot捕获（即父线程ThreadLocal内容），捕获后的Snapshot再回放如当前执行线程，达到线程池内线程执行时，父子线程上下文传递的效果。详见源码。

现状说明

目前的日志系统，由于上述提到的MDC的原理，不能进行线程上下文traceId的传递，在实际日志排查过程中，某链路日志数据当遇到线程执行时，线索断裂的问题。所以，通过TTL的基本原理，一方面我们要改写MDC的Adapter，将其ThreadLocal的日志信息替换为TransmittableThreadLocal，其次，在执行所有的线程或线程池时，将其使用TTL技术进行修饰。当然TTL提供了javaagent的方式，通过javaassist对线程执行进行了代理改写，可直接将TtlRunnable的方式注入到现有的业务中，减少业务侵入性。

5.2、使用阿里TTL解决线程池内父子线程数据传递问题

部署步骤

增加MDC适配器

增加TtlMDCAdapter，用于替换MDC的适配器，因MDC的静态适配器是在包维度可修改的，所以自定义的TtlMDCAdapter，需按org.slf4j.*的包形式进行存放。源码文件如下：

package org.slf4j;
import com.alibaba.ttl.TransmittableThreadLocal;
import org.slf4j.MDC;
import org.slf4j.spi.MDCAdapter;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
public class TtlMDCAdapter implements MDCAdapter {
    final ThreadLocal<Map<String, String>> copyOnInheritThreadLocal = new TransmittableThreadLocal<>();
    private static final int WRITE_OPERATION = 1;
    private static final int READ_OPERATION = 2;
    private static TtlMDCAdapter mtcMDCAdapter;
    // keeps track of the last operation performed
    final ThreadLocal<Integer> lastOperation = new ThreadLocal<>();
    static {
        mtcMDCAdapter = new TtlMDCAdapter();
        MDC.mdcAdapter = mtcMDCAdapter;
    }
    public static MDCAdapter getInstance() {
        return mtcMDCAdapter;
    }
    private Integer getAndSetLastOperation(int op) {
        Integer lastOp = lastOperation.get();
        lastOperation.set(op);
        return lastOp;
    }
    private static boolean wasLastOpReadOrNull(Integer lastOp) {
        return lastOp == null || lastOp == READ_OPERATION;
    }
    private Map<String, String> duplicateAndInsertNewMap(Map<String, String> oldMap) {
        Map<String, String> newMap = Collections.synchronizedMap(new HashMap<String, String>());
        if (oldMap != null) {
            // we don't want the parent thread modifying oldMap while we are
            // iterating over it
            synchronized (oldMap) {
                newMap.putAll(oldMap);
            }
        }
        copyOnInheritThreadLocal.set(newMap);
        return newMap;
    }
    /**
     * Put a context value (the <code>val</code> parameter) as identified with the
     * <code>key</code> parameter into the current thread's context map. Note that
     * contrary to log4j, the <code>val</code> parameter can be null.
     * <p/>
     * <p/>
     * If the current thread does not have a context map it is created as a side
     * effect of this call.
     *
     * @throws IllegalArgumentException in case the "key" parameter is null
     */
    @Override
    public void put(String key, String val) {
        if (key == null) {
            throw new IllegalArgumentException("key cannot be null");
        }
        Map<String, String> oldMap = copyOnInheritThreadLocal.get();
        Integer lastOp = getAndSetLastOperation(WRITE_OPERATION);
        if (wasLastOpReadOrNull(lastOp) || oldMap == null) {
            Map<String, String> newMap = duplicateAndInsertNewMap(oldMap);
            newMap.put(key, val);
        } else {
            oldMap.put(key, val);
        }
    }
    /**
     * Remove the the context identified by the <code>key</code> parameter.
     * <p/>
     */
    @Override
    public void remove(String key) {
        if (key == null) {
            return;
        }
        Map<String, String> oldMap = copyOnInheritThreadLocal.get();
        if (oldMap == null) {
            return;
        }
        Integer lastOp = getAndSetLastOperation(WRITE_OPERATION);
        if (wasLastOpReadOrNull(lastOp)) {
            Map<String, String> newMap = duplicateAndInsertNewMap(oldMap);
            newMap.remove(key);
        } else {
            oldMap.remove(key);
        }
    }
    /**
     * Clear all entries in the MDC.
     */
    @Override
    public void clear() {
        lastOperation.set(WRITE_OPERATION);
        copyOnInheritThreadLocal.remove();
    }
    /**
     * Get the context identified by the <code>key</code> parameter.
     * <p/>
     */
    @Override
    public String get(String key) {
        Map<String, String> map = getPropertyMap();
        if ((map != null) && (key != null)) {
            return map.get(key);
        } else {
            return null;
        }
    }
    /**
     * Get the current thread's MDC as a map. This method is intended to be used
     * internally.
     */
    public Map<String, String> getPropertyMap() {
        lastOperation.set(READ_OPERATION);
        return copyOnInheritThreadLocal.get();
    }
    /**
     * Return a copy of the current thread's context map. Returned value may be
     * null.
     */
    @Override
    public Map getCopyOfContextMap() {
        lastOperation.set(READ_OPERATION);
        Map<String, String> hashMap = copyOnInheritThreadLocal.get();
        if (hashMap == null) {
            return null;
        } else {
            return new HashMap<>(hashMap);
        }
    }
    @SuppressWarnings("unchecked")
    @Override
    public void setContextMap(Map contextMap) {
        lastOperation.set(WRITE_OPERATION);
        Map<String, String> newMap = Collections.synchronizedMap(new HashMap<String, String>());
        newMap.putAll(contextMap);
        // the newMap replaces the old one for serialisation's sake
        copyOnInheritThreadLocal.set(newMap);
    }
}

增加TtlMDCAdapterInitializer，在springboot启动时，加载初始化MDC适配器，源码如下：

package cn.gov.zcy.indenture.initializers;
import org.slf4j.TtlMDCAdapter;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
public class TtlMDCAdapterInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
        // 加载自定义的MDCAdapter
        TtlMDCAdapter.getInstance();
    }
}

main方法

SpringApplication springApplication = new SpringApplication(WebApplication.class);
springApplication.addInitializers(new TtlMDCAdapterInitializer());
final Environment env = springApplication.run(args).getEnvironment();

使用javaagent代理

联系运维在应用 + 环境，设置transmittable-thread-local-2.11.0.jar包。
transmittable-thread-local-2.11.0.jar包文件
增加启动参数：-javaagent:/opt/transmittable-thread-local/transmittable-thread-local-2.11.0.jar

测试效果

注意事项

考虑到ttl传递的值是weak指针、按threadlocal进行copy、虽然也有map拷贝时的加锁动作，但是在影响面上要考虑下，用户session信息是否存在串掉的场景。「需要考虑注意」

JUC第六讲：ThreadLocal/InheritableThreadLocal详解/TTL-MDC日志上下文实践

1、ThreadLocal是什么？有哪些用途？

1.1、ThreadLocal的定义

1.2、ThreadLocal 作用

1.3、ThreadLocalMap 的定义

1.4、set() 方法

1.5、get() 方法

1.6、remove() 方法

1.7、expungeStaleEntry 方法

1.8、rehash 方法

1.9、功能测试

2、ThreadLocal 内存泄漏问题

3、ThreadLocal 总结

4、InheritableThreadLocal 详解

4.1、定义

4.2、源码

4.3、InheritableThreadLocal 继承父线程的值

4.4、功能测试

4.5、InheritableThreadLocal 变量的可见性探讨

4.6、重写childValue()方法实现子线程与父线程之间互不影响

5、TTL-MDC日志上下文实践

5.1、现状

5.2、使用阿里TTL解决线程池内父子线程数据传递问题

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

JUC第六讲：ThreadLocal/InheritableThreadLocal详解/TTL-MDC日志上下文实践

1、ThreadLocal是什么？有哪些用途？

1.1、ThreadLocal的定义

1.2、ThreadLocal 作用

1.3、ThreadLocalMap 的定义

1.4、set() 方法

1.5、get() 方法

1.6、remove() 方法

1.7、expungeStaleEntry 方法

1.8、rehash 方法

1.9、功能测试

2、ThreadLocal 内存泄漏问题

3、ThreadLocal 总结

4、InheritableThreadLocal 详解

4.1、定义

4.2、源码

4.3、InheritableThreadLocal 继承父线程的值

4.4、功能测试

4.5、InheritableThreadLocal 变量的可见性探讨

4.6、重写childValue()方法实现子线程与父线程之间互不影响

5、TTL-MDC日志上下文实践

5.1、现状

5.2、使用阿里TTL解决线程池内父子线程数据传递问题

热门文章

最新文章

相关课程

相关电子书

相关实验场景