• JUC第六讲：ThreadLocal/InheritableThreadLocal详解

    本文是JUC第三十一讲：ThreadLocal/InheritableThreadLocal详解。ThreadLocal是通过线程隔离的方式防止任务在共享资源上产生冲突，线程本地存储是一种自动化机制，可以为使用相同变量的每个不同线程都创建不同的存储。ThreadLocal无论在项目开发还是面试中都会经常碰到，本文就 ThreadLocal 的使用、主要方法源码详解、内存泄漏问题展开讨论 ，最后讲解阿里TTL在日志上下文中的实践。

    文章目录

    1、带着BAT大厂的面试问题去理解

    请带着这些问题继续后文，会很大程度上帮助你更好的理解相关知识点。

    • 什么是ThreadLocal? 用来解决什么问题的？
    • 说说你对ThreadLocal的理解？线程本地变量，为每个线程创建单独的变量副本
    • ThreadLocal是如何实现线程隔离的？
    • 为什么ThreadLocal会造成内存泄露? 如何解决
    • 还有哪些使用ThreadLocal的应用场景?

    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);
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 从上面的定义可以知道，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
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46

    • 使用场景

      • 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
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9

    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
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15

    • 代码块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
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 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
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 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;
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 从 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();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    • 跟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
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 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
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 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;    // 找不到, 返回空
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 从元素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;
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 方法很简单，拿到当前线程的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;   
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35

      • 源码解读：从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
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 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());
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    输出结果：

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

    • 1
    • 2
    • 3
    • 4

    从输出结果可以看出，线程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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    • 从上面源码可以看出，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.
     * 
      
     * 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);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      /* 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;

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9

    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++;
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50

    • 这是线程被创建的整个流程，从第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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    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 + "]";
        }
 
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159

    输出结果：
    在这里插入图片描述

    代码中都注释写清楚了，主要是根据存放可变对象 (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;
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82

    输出结果

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

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    通过结果，我们可以看出重写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解决线程池内父子线程数据传递问题

    部署步骤

      1. 增加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 val parameter) as identified with the
     * key parameter into the current thread's context map. Note that
     * contrary to log4j, the val parameter can be null.
     * 
      
     * 
      
     * 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 key parameter.
     * 
      
     */
    @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 key parameter.
     * 
      
     */
    @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);
 
 
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88
      • 89
      • 90
      • 91
      • 92
      • 93
      • 94
      • 95
      • 96
      • 97
      • 98
      • 99
      • 100
      • 101
      • 102
      • 103
      • 104
      • 105
      • 106
      • 107
      • 108
      • 109
      • 110
      • 111
      • 112
      • 113
      • 114
      • 115
      • 116
      • 117
      • 118
      • 119
      • 120
      • 121
      • 122
      • 123
      • 124
      • 125
      • 126
      • 127
      • 128
      • 129
      • 130
      • 131
      • 132
      • 133
      • 134
      • 135
      • 136
      • 137
      • 138
      • 139
      • 140
      • 141
      • 142
      • 143
      • 144
      • 145
      • 146
      • 147
      • 148
      • 149
      • 150
      • 151
      • 152
      • 153
      • 154
      • 155
      • 156
      • 157
      • 158
      • 159
      • 160
      • 161
      • 162
      • 163
      • 164
      • 165
      • 166
      • 167
      • 168
      • 169
      • 170
      • 171

    • 增加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();
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14

    • main方法

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

      • 1
      • 2
      • 3
      1. 使用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
      • 在这里插入图片描述
      1. 测试效果
      • 在这里插入图片描述

    • 注意事项

      • 考虑到ttl传递的值是weak指针、按threadlocal进行copy、虽然也有map拷贝时的加锁动作，但是在影响面上要考虑下，用户session信息是否存在串掉的场景。「需要考虑注意」
  • 相关阅读:
    ChatGPT做测试助手，轻轻松提升工作效率！
    实用笔记-java配置
    35岁的腾讯测试员退休？答：存够2千万回家买房
    b树（一篇文章带你 理解 ）
    SIMD 加速：AVX2 指令集实现大小端转换
    helm 部署golang应用
    并查集：基本操作、路径压缩
    MMDeploy快速安装及使用说明
    【CSS】全局滚动条样式设置
    【做题笔记】多项式/FFT/NTT
  • 原文地址：https://blog.csdn.net/qq_28959087/article/details/120043053