转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

本文来自一枝花算不算浪漫投稿， 原文地址： https://juejin.cn/post/6844904151567040519open in new window。 感谢作者!

思维导图

目录 #

ThreadLocal代码演示 #

简单使用

public class ThreadLocalTest {
    private List<String> messages = Lists.newArrayList();

    public static final ThreadLocal<ThreadLocalTest> holder = ThreadLocal.withInitial(ThreadLocalTest::new);

    public static void add(String message) {
        holder.get().messages.add(message);
    }

    public static List<String> clear() {
        List<String> messages = holder.get().messages;
        holder.remove();

        System.out.println("size: " + holder.get().messages.size());
        return messages;
    }

    public static void main(String[] args) {
        ThreadLocalTest.add("一枝花算不算浪漫");
        System.out.println(holder.get().messages);
        ThreadLocalTest.clear();
    }
}
/* 结果 
[一枝花算不算浪漫]
size: 0
*/

简单使用2

@Data
class LyTest{
    private ThreadLocal<String> threadLocal=ThreadLocal.withInitial(()->{
        return "hello";
    });
}
public class ThreadLocalTest {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch=new CountDownLatch(2);


        LyTest lyTest=new LyTest();
        ThreadLocal<String> threadLocal = lyTest.getThreadLocal();
        new Thread(()->{
            String name = Thread.currentThread().getName();
            threadLocal.set(name+ "-ly");
            System.out.println(name+"：threadLocal当前值"+threadLocal.get());
            countDownLatch.countDown();
        },"线程1").start();
        new Thread(()->{
            String name = Thread.currentThread().getName();
            threadLocal.set(name+ "-ly");
            System.out.println(name+"：threadLocal当前值"+threadLocal.get());
            countDownLatch.countDown();
        },"线程2").start();
        /*while (true){}*/
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName()+"：threadLocal当前值"+threadLocal.get());


    }
}
/*
线程1：threadLocal当前值线程1-ly
线程2：threadLocal当前值线程2-ly
main：threadLocal当前值hello
*/

ThreadLocal对象可以提供线程局部变量，每个线程Thread拥有一份自己的副本变量，多个线程互不干扰。

回顾之前的知识点

public void set(T value) {
    //获取当前请求的线程    
    Thread t = Thread.currentThread();
    //取出 Thread 类内部的 threadLocals 变量(哈希表结构)
    ThreadLocalMap map = getMap(t);
    if (map != null)
        // 将需要存储的值放入到这个哈希表中
        //★★实际使用的方法
        map.set(this, value);
    else
        //★★实际使用的方法
        createMap(t, value);
}
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

• 如上，实际存取都是从Thread的threadLocals （ThreadLocalMap类）中，并不是存在ThreadLocal上，ThreadLocal用来传递了变量值，只是ThreadLocalMap的封装
• ThreadLocal类中通过Thread.currentThread()获取到当前线程对象后，直接通过getMap(Thread t) 可以访问到该线程的ThreadLocalMap对象
• 每个Thread中具备一个ThreadLocalMap，而ThreadLocalMap可以存储以ThreadLocal为key，Object对象为value的键值对

ThreadLocal的数据结构 #

由上面回顾的知识点可知，value实际上都是保存在**线程类(Thread类)中的某个属性(ThreadLocalMap类)**中

ThreadLocalMap的底层是一个数组（map的底层是数组）

Thread类有一个类型为**ThreadLocal.ThreadLocalMap**的实例变量threadLocals，也就是说每个线程有一个自己的ThreadLocalMap。 ThreadLocalMap是一个静态内部类

没有修饰符，为包可见。比如父类有一个protected修饰的方法f()，不同包下存在子类A和其他类X，在子类中可以访问方法f()，即使在其他类X创建子类A实例a1，也不能调用a1.f()–> 其他包不可见

ThreadLocalMap有自己独立实现，简单地将它的key视作ThreadLocal，value为代码中放入的值，（看底层代码可知，实际key不是ThreadLocal本身，而是它的一个弱引用）

★每个线程在往ThreadLocal里放值的时候，都会往自己的ThreadLocalMap里存，读也是以ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离。

ThreadLocalMap有点类似HashMap的结构，只是HashMap是由数组+链表实现的，而ThreadLocalMap中并没有链表结构。其中，还要注意Entry类， 它的key是ThreadLocal<?> k ，(Entry类)继承自WeakReference， 也就是我们常说的弱引用类型。

如下，有个数组存放Entry(弱引用类，且有属性value)，且

---

static class ThreadLocalMap { 
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
    //.....
}

为上面的知识点总结一张图 #

GC之后key是否为null #

WeakReference的使用

WeakReference<Car> weakCar = new WeakReference(Car)(car); 
weakCar.get();  //如果值为null表示已经被回收了

问题： ThreadLocal的key为弱引用，那么在ThreadLocal.get()的时候，发生GC之后，key是否为null

• Java的四种引用类型
  • 强引用：通常情况new出来的为强引用，只要强引用存在，垃圾回收器永远不会回收被引用的对象（即使内存不足）
  • 软引用：使用SoftReference修饰的对象称软引用，软引用指向的对象在内存要溢出的时候被回收
  • 弱引用：使用WeakReference修饰的对象称为弱引用，只要发生垃圾回收，如果这个对象只被弱引用指向，那么就会被回收
  • 虚引用：虚引用是最弱的引用，用PhantomReference定义。唯一的作用就是用队列接收对象即将死亡的通知

使用反射方式查看GC后ThreadLocal中的数据情况

import java.lang.reflect.Field;

/*
t.join()方法阻塞调用此方法的线程(calling thread)进入 TIMED_WAITING 状态，直到线程t完成，此线程再继续
*/
public class ThreadLocalDemo {

    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InterruptedException {
        Thread t = new Thread(()->test("abc",false));
        t.start();
        t.join();
        System.out.println("--gc后--");
        Thread t2 = new Thread(() -> test("def", true));
        t2.start();
        t2.join();
    }

    private static void test(String s,boolean isGC)  {
        try {
            //注意这一行,这个ThreadLocal对象是不存在任何强引用的
            new ThreadLocal<>().set(s);//当前线程设置了一个值 s
            if (isGC) {
                System.gc();
            }
            Thread t = Thread.currentThread();
            Class<? extends Thread> clz = t.getClass();
            Field field = clz.getDeclaredField("threadLocals");
            field.setAccessible(true);
            Object threadLocalMap = field.get(t);//得到当前线程的ThreadLocalMap
            Class<?> tlmClass = threadLocalMap.getClass();
            Field tableField = tlmClass.getDeclaredField("table");
            tableField.setAccessible(true);
            //注意：这里获取的是threadLocalMap内部的(维护)数组 private Entry[] table; 
            Object[] arr = (Object[]) tableField.get(threadLocalMap);
            for (Object o : arr) {
                if (o != null) {
                    Class<?> entryClass = o.getClass();
                    /* Entry结构
                    static class Entry extends WeakReference<ThreadLocal<?>> {
                        //The value associated with this ThreadLocal. 
                        Object value;

                        Entry(ThreadLocal<?> k, Object v) {
                            super(k);
                            value = v;
                        }
        			}
                    */
                    //获取Entry中的值（键值对的“值”）
                    Field valueField = entryClass.getDeclaredField("value");
                    //Entry extends WeakReference 
                    //WeakReference<T> extends Reference<T> 
                    //Reference 里面有一个属性 referent ，指向实际的对象，即key实际的对象
                    Field referenceField = entryClass.getSuperclass().getSuperclass().getDeclaredField("referent");
                    valueField.setAccessible(true);
                    referenceField.setAccessible(true);
                    System.out.println(String.format("弱引用key:%s,值:%s", referenceField.get(o), valueField.get(o)));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
/* 结果如下
弱引用key:java.lang.ThreadLocal@433619b6,值:abc
弱引用key:java.lang.ThreadLocal@418a15e3,值:java.lang.ref.SoftReference@bf97a12
--gc后--
弱引用key:null,值:def
*/

gc之后的图：
new ThreadLocal<>().set(s); GC之后，key就会被回收，我们看到上面的debug中referent=null

如果这里修改代码，

ThreadLocal<Object> threadLocal=new ThreadLocal<>();
threadLocal.set(s);

使用弱引用+垃圾回收

如上，垃圾回收前，ThreadLoal是存在强引用的，因此如果如上修改代码，则key不为null

当不存在强引用时，key会被回收，即出现value没被回收，key被回收，导致key永远存在，内存泄漏

ThreadLocal.set()方法源码详解 #

如图所示

ThreadLocal中的set()方法原理如上，先取出线程Thread中的threadLocals，判断是否存在，然后使用ThreadLocal中的set方法进行数据处理

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

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

ThreadLocalMap Hash算法 #

ThreadLocalMap实现了自己的hash算法来解决散列表数组冲突问题：

//i为当前key在散列表中对应的数组下标位置
//即(len-1)和和斐波那契数做 与运算
int i = key.threadLocalHashCode & (len-1);

threadLocalHashCode值的计算，ThreadLocal中有一个属性为HASH_INCREMENT = 0x61c88647

0x61c88647，又称为斐波那契数也叫黄金分割数，hash增量为这个数，好处是hash 分布非常均匀

public class ThreadLocal<T> {
    private final int threadLocalHashCode = nextHashCode();

    private static AtomicInteger nextHashCode = new AtomicInteger();

    private static final int HASH_INCREMENT = 0x61c88647;

    //hashCode增加
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

    static class ThreadLocalMap {
        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);

            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }
    }
} 

例子如下，产生的哈希码分布十分均匀

★★ 说明，下面的所有示例图中，绿色块Entry代表为正常数据，灰色块代表Entry的key为null，已被垃圾回收。白色块代表Entry为null（或者说数组那个位置为null(没有指向)）

ThreadLocalMap Hash冲突 #

• ThreadLocalMap 中使用黄金分割数作为hash计算因子，大大减少Hash冲突的概率
• HashMap中解决冲突的方法，是在数组上构造一个链表结构，冲突的数据挂载到链表上，如果链表长度超过一定数量则会转化为红黑树
• ThreadLocalMap中没有链表结构（使用线性向后查找）
  • 如图
  • 假设需要插入value = 27 的数据，hash后应该落入槽位4，而槽位已经有了Entry数据
  • 此时线性向后查找，一直找到Entry为null的操作才会停止查找，将当前元素放入该槽位中
  • 线性向后查找迭代中，会遇到Entry不为null且key值相等，以及**Entry中的key为null（图中Entry 为 2）**的情况，处理方式不同
    • set过程中如果遇到了key过期(key为null)的Entry数据，实际上会进行一轮探测式清理操作

ThreadLocalMap.set() 详解 #

ThreadLocalMap.set() 原理图解

往ThreadLocalMap中set数据（新增或更新数据）分为好几种

1. 通过hash计算后的槽位对应的Entry数据为空 直接将数据放到该槽位即可

2. 槽位数据不为空，key值与当前ThreadLocal通过hash计算获取的key值一致 直接更新该槽位的数据

3. 槽位数据不为空，往后遍历过程中，在找到Entry为null的槽位之前，没有遇到过期的Entry 遍历散列数组的过程中，线性往后查找，如果找到Entry为null的槽位则将数据放入槽位中；或者往后遍历过程中遇到key值相等的数据则更新

4. 槽位数据不为空，在找到Entry为null的槽位之前，遇到了过期的Entry，如下图 此时会执行replaceStableEntry()方法，该方法含义是替换过期数据的逻辑

   … 以下省略，太复杂

   替换完成后也是进行过期元素清理工作，清理工作主要是有两个方法：expungeStaleEntry()和cleanSomeSlots()

   经过迭代处理后，有过Hash冲突数据的Entry位置会更靠近正确位置，这样的话，查询的时候 效率才会更高。

ThreadLocalMap过期 key 的探测式清理流程(略过) #

ThreadLocalMap扩容机制 #

在ThreadLocalMap.set()方法的最后，如果执行完启发式清理工作后，未清理到任何数据，且当前散列数组中Entry的数量已经达到了列表的扩容阈值(len*2/3)，就开始执行rehash()逻辑：

if (!cleanSomeSlots(i, sz) && sz >= threshold)
    rehash();

rehash()的具体实现

private void rehash() {
    expungeStaleEntries();

    if (size >= threshold - threshold / 4)
        resize();
}

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)
            expungeStaleEntry(j);
    }
} 

注意：

1. threshold [ˈθreʃhəʊld], 门槛 = length * 2/3

2. rehash之前进行一次容量判断( 是否 > threshold , 是则rehash)

3. rehash时先进行expungeStaleEntries() （探索式清理，从table起始为止）

   这里首先是会进行探测式清理工作，从table的起始位置往后清理，上面有分析清理的详细流程。清理完成之后，table中可能有一些key为null的Entry数据被清理掉，所以此时通过判断size >= threshold - threshold / 4 也就是size >= threshold * 3/4 来决定是否扩容。

4. 清理后如果大于 threshold 的3/4 ，则进行扩容

5. 具体的resize()方法 以oldTab .len = 8

   1. 容后的tab的大小为oldLen * 2 =16

   2. 遍历老的散列表，重新计算hash位置，然后放到新的tab数组中，如果出现hash冲突则往后寻找最近的entry为null的槽位

   3. 遍历完成之后，oldTab中所有的entry数据都已经放入到新的tab中了。重新计算tab下次扩容的阈值 代码如下

      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) {
                  ThreadLocal<?> k = e.get();
                  if (k == null) {
                      e.value = null;
                  } else {
                      int h = k.threadLocalHashCode & (newLen - 1);
                      while (newTab[h] != null)
                          h = nextIndex(h, newLen);
                      newTab[h] = e;
                      count++;
                  }
              }
          }
      
          setThreshold(newLen);
          size = count;
          table = newTab;
      } 
      

ThreadLocalMap.get() 详解 #

1. 通过查找key值计算出散列表中slot位置，然后该slot位置中的Entry.key和查找的key一致，则直接返回

2. slot位置中的Entry.key和要查找的key不一致，之后清理+遍历

   我们以get(ThreadLocal1)为例，通过hash计算后，正确的slot位置应该是 4，而index=4的槽位已经有了数据，且key值不等于ThreadLocal1，所以需要继续往后迭代查找。

   迭代到index=5的数据时，此时Entry.key=null，触发一次探测式数据回收操作，执行expungeStaleEntry()方法，执行完后，index 5,8的数据都会被回收，而index 6,7的数据都会前移。index 6,7前移之后，继续从 index=5 往后迭代，于是就在 index=5 找到了key值相等的Entry数据，如下图所示：

3. ThreadLocalMap.get()源码详解

   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);
           else
               i = nextIndex(i, len);
           e = tab[i];
       }
       return null;
   } 
   

ThreadLocalMap过期key的启发式清理流程(略过，跟移位运算符有关) #

上面多次提及到ThreadLocalMap过期key的两种清理方式：探测式清理(expungeStaleEntry())、启发式清理(cleanSomeSlots())

探测式清理是以当前Entry 往后清理，遇到值为null则结束清理，属于线性探测清理。

而启发式清理被作者定义为：Heuristically scan some cells looking for stale entries.

Inheritable ThreadLocal #

使用ThreadLocal的时候，在异步场景下是无法给子线程共享父线程中创建的线程副本数据的。JDK中存在InheritableThreadLocal类可以解决处理这个问题

原理： 子线程是通过在父线程中通过new Thread()方法创建子线程，Thread#init 方法在Thread的构造方法中被调用，init方法中拷贝父线程数据到子线程中

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);
    this.stackSize = stackSize;
    tid = nextThreadID();
} 

public class InheritableThreadLocalDemo {
    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数据：" + ThreadLocal.get());
                System.out.println("子线程获取父类inheritableThreadLocal数据：" + inheritableThreadLocal.get());
            }
        }).start();
    }
}
/*结果
子线程获取父类ThreadLocal数据：null
子线程获取父类inheritableThreadLocal数据：父类数据:inheritableThreadLocal
*/

但是如果不是直接new()，也就是实际中我们都是通过使用线程池来获取新线程的，那么可以使用阿里开源的一个组件解决这个问题 TransmittableThreadLocal

ThreadLocal项目中使用实战 #

这里涉及到requestId，没用过，不是很懂，略过

ThreadLocal使用场景 #

Feign远程调用解决方案 #

线程池异步调用,requestId 传递 #

使用MQ发送消息给第三方系统 #