文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

并发编程之ThreadLocal深入理解

2024-12-03 15:36

关注

 前言

在日常的开发中，我们经常会遇到在当前运行线程中保存一些信息，并且各线程之间是隔离的，不会相互影响，不存在并发问题，通过这样的方式来实现请求调用链中方法之间参数传递的解耦，提升代码结构的稳定性等。Java ThreadLocal就是用于实现这一目标的。在学习之前我们先带着以下几个问题：

  1. ThreadLocal 是什么?
  2. ThreadLocal 怎么用?
  3. ThreadLocal 和线程同步机制相比较?
  4. ThreadLocal 是如何实现线程隔离的呢?
  5. ThreadLocal 如何避免内存泄漏呢?
  6. ThreadLocal 与 Thread、ThreadLocalMap 之间的关系?

以下分析均基于JDK1.8。

什么是ThreadLocal

ThreadLocal，很多地方叫做线程本地变量，也有些地方叫做线程本地存储。

ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量，这样同时多个线程访问该变量并不会彼此相互影响，因此他们使用的都是自己从内存中拷贝过来的变量的副本，这样就不存在线程安全问题，也不会影响程序的执行性能。

注意：虽然ThreadLocal能够解决上面说的问题，但是由于在每个线程中都创建了副本，所以要考虑它对资源的消耗，比如内存的占用会比不使用ThreadLocal要大。

ThreadLocal 怎么用

通常使用静态的变量来维护ThreadLocal，如:

  1. static ThreadLocal sThreadLocal = new ThreadLocal 

会自动在每一个线程上创建一个 T 的副本，副本之间彼此独立，互不影响，可以用 ThreadLocal 存储一些参数，以便在线程中多个方法中使用，用以代替方法传参的做法。

通过一个例子来了解 ThreadLocal：

  1. package com.niuh.threadlocal; 
  2.  
  3.  
  4. public class ThreadLocalDemo { 
  5.      
  6.     public static final ThreadLocal THREAD_LOCAL = new ThreadLocal<>(); 
  7.  
  8.     public static void main(String[] args) throws Exception { 
  9.         new ThreadLocalDemo().threadLocalTest(); 
  10.     } 
  11.  
  12.     public void threadLocalTest() throws Exception { 
  13.         // 主线程设置值 
  14.         THREAD_LOCAL.set("一角钱技术"); 
  15.         String v = THREAD_LOCAL.get(); 
  16.         System.out.println("Thread-0线程执行之前，" + Thread.currentThread().getName() + "线程取到的值：" + v); 
  17.  
  18.         new Thread(new Runnable() { 
  19.             @Override 
  20.             public void run() { 
  21.                 String v = THREAD_LOCAL.get(); 
  22.                 System.out.println(Thread.currentThread().getName() + "线程取到的值：" + v); 
  23.                 // 设置 threadLocal 
  24.                 THREAD_LOCAL.set("一角钱技术2020"); 
  25.                 v = THREAD_LOCAL.get(); 
  26.                 System.out.println("重新设置之后，" + Thread.currentThread().getName() + "线程取到的值为：" + v); 
  27.                 System.out.println(Thread.currentThread().getName() + "线程执行结束"); 
  28.             } 
  29.         }).start(); 
  30.         // 等待所有线程执行结束 
  31.         Thread.sleep(3000L); 
  32.         v = THREAD_LOCAL.get(); 
  33.         System.out.println("Thread-0线程执行之后，" + Thread.currentThread().getName() + "线程取到的值：" + v); 
  34.     } 
  35. } 

 首先通过 static final 定义了一个 THREAD_LOCAL 变量，其中 static 是为了确保全局只有一个保存 String 对象的 ThreadLocal 实例;final 确保 ThreadLocal 的实例不可更改，防止被意外改变，导致放入的值和取出来的不一致，另外还能防止 ThreadLocal 的内存泄漏。上面的例子是演示在不同的线程中获取它会得到不同的结果，运行结果如下：

  1. Thread-0线程执行之前，main线程取到的值：一角钱技术 
  2. Thread-0线程取到的值：null 
  3. 重新设置之后，Thread-0线程取到的值为：一角钱技术2020 
  4. Thread-0线程执行结束 
  5. Thread-0线程执行之后，main线程取到的值：一角钱技术 

看到这里，我相信大家一定会好奇 ThreadLocal 是如何做到多个线程对同一对象 set 操作，但是 get 获取的值还都是每个线程 set 的值呢。

ThreadLocal和线程同步机制相比较

ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。

在同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的，使用同步机制要求程序慎密地分析什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放对象锁等繁杂的问题，程序设计和编写难度相对较大。

而ThreadLocal则从另一个角度来解决多线程的并发访问。ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进ThreadLocal。

总的来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

ThreadLocal源码解析


成员变量

  1. // 当前 ThreadLocal 的 hashCode，由 nextHashCode() 计算而来 
  2. // 用于计算当前 ThreadLocal 在 ThreadLocalMap 中的索引位置 
  3. private final int threadLocalHashCode = nextHashCode(); 
  4. // 哈希魔数，主要与斐波那契散列法以及黄金分割有关 
  5. private static final int HASH_INCREMENT = 0x61c88647; 
  6. // 返回计算出的下一个哈希值，其值为 i * HASH_INCREMENT，其中 i 代表调用次数 
  7. private static int nextHashCode() { 
  8.     return nextHashCode.getAndAdd(HASH_INCREMENT); 
  9. } 
  10. // 保证了在一台机器中每个 ThreadLocal 的 threadLocalHashCode 是唯一的 
  11. private static AtomicInteger nextHashCode = new AtomicInteger(); 

 其中的 HASH_INCREMENT 也不是随便取的，它转化为十进制是 1640531527，2654435769 转换成 int 类型就是 -1640531527，2654435769 等于 (√5-1)/2 乘以 2 的 32 次方。(√5-1)/2 就是黄金分割数，近似为 0.618，也就是说 0x61c88647 理解为一个黄金分割数乘以 2 的 32 次方，它可以保证 nextHashCode 生成的哈希值，均匀的分布在 2 的幂次方上，且小于 2 的 32 次方。

下面是 javaspecialists 中一篇文章对它的介绍：

下面用例子来证明下：

  1. private static final int HASH_INCREMENT = 0x61c88647; 
  2.  
  3. public static void main(String[] args) throws Exception { 
  4.     int n = 5; 
  5.     int max = 2 << (n - 1); 
  6.     for (int i = 0; i < max; i++) { 
  7.         System.out.print(i * HASH_INCREMENT & (max - 1)); 
  8.         System.out.print(" "); 
  9.  
  10.     } 
  11. } 

 运行结果为：0 7 14 21 28 3 10 17 24 31 6 13 20 27 2 9 16 23 30 5 12 19 26 1 8 15 22 29 4 11 18 25

可以发现元素索引值完美的散列在数组当中，并没有出现冲突。

内部类ThreadLocalMap

ThreadLocalMap 是 ThreadLocal 的静态内部类，当一个线程有多个 ThreadLocal 时，需要一个容器来管理多个 ThreadLocal，ThreadLocalMap 的作用就是管理线程中多个 ThreadLocal。

ThreadLocalMap 其实就是一个简单的 Map 结构，底层是数组，有初始化大小，也有扩容阈值大小，数组的元素是 Entry。

ThreadLocalMap的数据结构是一个用数组表示的环，数组长度必须是2的次幂，同样通过hash方式确定节点在数组中的下标(hash值是ThreadLocal的递增变量，而不是hashcode值)，对于hash冲突的情况，采用线性探测法，直接将元素防止对应下标后面的下一个空闲单元。

ThreadLocalMap的key采用的是弱引用WeakReference，因此在使用过程中还需要注意及时清理key已经被gc回收的节点，及时释放无效空间。

关于弱引用可以查看《Java基础 |强引用、弱引用、软引用、虚引用》

成员属性

  1. // 初始容量，必须为 2 的幂 
  2. private static final int INITIAL_CAPACITY = 16; 
  3.  
  4. // 存储 ThreadLocal 的键值对实体数组，长度必须为 2 的幂 
  5. private Entry[] table; 
  6.  
  7. // ThreadLocalMap 元素数量 
  8. private int size = 0; 
  9.  
  10. //扩容的阈值，默认是数组大小的三分之二 
  11. private int threshold; // Default to 0 

 Entry类

Entry是ThreadLocalMap的内部类，用来表示其中的节点，继承了弱引用WeadReference类。

  1. // 键值对实体的存储结构 
  2. static class Entry extends WeakReference> { 
  3.     // 当前线程关联的 value，这个 value 并没有用弱引用追踪 
  4.     Object value; 
  5.        
  6.     Entry(ThreadLocal k, Object v) { 
  7.         super(k); 
  8.         value = v; 
  9.     } 
  10. } 

 Entry 的 key 就是 ThreadLocal 的引用，value 是 ThreadLocal 的值。同时，Entry也继承WeakReference，所以说Entry所对应key(ThreadLocal实例)的引用是一个弱引用。

构造方法

1.ThreadLocalMap 提供了两个构造方法：

  1. ThreadLocalMap(ThreadLocal firstKey, Object firstValue) { 
  2.     table = new Entry[INITIAL_CAPACITY]; 
  3.     int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); 
  4.     table[i] = new Entry(firstKey, firstValue); 
  5.     size = 1; 
  6.     setThreshold(INITIAL_CAPACITY); 
  7. } 

2.ThreadLocalMap#ThreadLocalMap(ThreadLocalMap)

  1. private ThreadLocalMap(ThreadLocalMap parentMap) { 
  2.     Entry[] parentTable = parentMap.table; 
  3.     int len = parentTable.length; 
  4.     setThreshold(len); 
  5.     table = new Entry[len]; 
  6.  
  7.     for (int j = 0; j < len; j++) { 
  8.         Entry e = parentTable[j]; 
  9.         if (e != null) { 
  10.             @SuppressWarnings("unchecked") 
  11.             ThreadLocal key = (ThreadLocal) e.get(); 
  12.             if (key != null) { 
  13.                 Object value = key.childValue(e.value); 
  14.                 Entry c = new Entry(key, value); 
  15.                 int h = key.threadLocalHashCode & (len - 1); 
  16.                 while (table[h] != null) 
  17.                     h = nextIndex(h, len); 
  18.                 table[h] = c; 
  19.                 size++; 
  20.             } 
  21.         } 
  22.     } 
  23. } 
    24. 

     初始化数组和threshold，遍历节点加入数组。
    

    擦除机制
    

    ThreadLocalMap中内部类Entry，继承了WeakReference，其key值是弱引用类型，在没有强引用时会被gc回收，因此ThreadLocalMap要及时对这部分过期节点进行擦除。
    

    1.ThreadLocalMap#expungeStaleEntry(int)
    

    1. private int expungeStaleEntry(int staleSlot) { 
    2.     Entry[] tab = table; 
    3.     int len = tab.length; 
    4.  
    5.     // expunge entry at staleSlot 
    6.     tab[staleSlot].value = null; 
    7.     tab[staleSlot] = null; 
    8.     size--; 
    9.  
    10.     // Rehash until we encounter null 
    11.     Entry e; 
    12.     int i; 
    13.     for (i = nextIndex(staleSlot, len); 
    14.          (e = tab[i]) != null; 
    15.          i = nextIndex(i, len)) { 
    16.         ThreadLocal k = e.get(); 
    17.         if (k == null) { 
    18.             e.value = null; 
    19.             tab[i] = null; 
    20.             size--; 
    21.         } else { 
    22.             int h = k.threadLocalHashCode & (len - 1); 
    23.             if (h != i) { 
    24.                 tab[i] = null; 
    25.  
    26.                 // Unlike Knuth 6.4 Algorithm R, we must scan until 
    27.                 // null because multiple entries could have been stale. 
    28.                 while (tab[h] != null) 
    29.                     h = nextIndex(h, len); 
    30.                 tab[h] = e; 
    31.             } 
    32.         } 
    33.     } 
    34.     return i; 
    35. } 
    

     擦除staleSlot处的无效节点，同时扫描处于staleSlot + 1 –  下一个null节点之间的节点，对于过期节点进行擦除，有效节点rehash，判断是否需要修改位置。
    

    2.ThreadLocalMap#expungeStaleEntries()
    

    1. private void expungeStaleEntries() { 
    2.     Entry[] tab = table; 
    3.     int len = tab.length; 
    4.     for (int j = 0; j < len; j++) { 
    5.         Entry e = tab[j]; 
    6.         if (e != null && e.get() == null) 
    7.             expungeStaleEntry(j); 
    8.     } 
    9. } 
    

     全量扫描擦除，遍历数组中的所有节点，对于过期节点调用擦除方法expungeStaleEntry进行擦除。
    

    3.ThreadLocalMap#cleanSomeSlots(int i, int n)
    

    1. private boolean cleanSomeSlots(int i, int n) { 
    2.     boolean removed = false; 
    3.     Entry[] tab = table; 
    4.     int len = tab.length; 
    5.     do { 
    6.         i = nextIndex(i, len); 
    7.         Entry e = tab[i]; 
    8.         if (e != null && e.get() == null) { 
    9.             n = len; 
    10.             removed = true; 
    11.             i = expungeStaleEntry(i); 
    12.         } 
    13.     } while ( (n >>>= 1) != 0); 
    14.     return removed; 
    15. } 
    

     启发式扫描擦除。从 i+1  开始扫描检查，如果连续log  n个单元不需要擦除则结束方法，否则找到一个过期节点，重置计数，将n置为数组长度，重新开始新一轮的扫描。只有扫描过程中有一个过期节点，则认为擦除成功，返回true。
    

    ThreadLocalMap#getEntry(ThreadLocal)
    

    1.  
    2. private Entry getEntry(ThreadLocal key) { 
    3.     int i = key.threadLocalHashCode & (table.length - 1); 
    4.     Entry e = table[i]; 
    5.     // 若 e 不为空，并且 e 的 ThreadLocal 的内存地址和 key 相同，直接返回 
    6.     if (e != null && e.get() == key) { 
    7.         return e; 
    8.     } else { 
    9.         // 碰撞查找，从 i 开始向后遍历找到键值对实体 
    10.         return getEntryAfterMiss(key, i, e); 
    11.     } 
    12. } 
    

     我们再来看一下getEntryAfterMiss方法：
    

    1. private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) { 
    2.     Entry[] tab = table; 
    3.     int len = tab.length; 
    4.  
    5.     while (e != null) { 
    6.         ThreadLocal k = e.get(); 
    7.         if (k == key) 
    8.             return e; 
    9.         if (k == null) 
    10.             expungeStaleEntry(i); 
    11.         else 
    12.             i = nextIndex(i, len); 
    13.         e = tab[i]; 
    14.     } 
    15.     return null; 
    16. } 
    

     用于在查找节点时没有直接命中的情况下进行线性的碰撞查找，对照查找过程中的过期节点，进行擦除。
    

    ThreadLocalMap#remove(ThreadLocal)
    

    1. private void remove(ThreadLocal key) { 
    2.     Entry[] tab = table; 
    3.     int len = tab.length; 
    4.     int i = key.threadLocalHashCode & (len-1); 
    5.     for (Entry e = tab[i]; 
    6.          e != null; 
    7.          e = tab[i = nextIndex(i, len)]) { 
    8.         if (e.get() == key) { 
    9.             e.clear(); 
    10.             expungeStaleEntry(i); 
    11.             return; 
    12.         } 
    13.     } 
    14. } 
    

     根据key值移除节点。找到节点后不是简单的将该节点置为null，还需要调用擦除方法，不然该节点后面的hash冲突节点会无法通过getEntry获取到。
    

    ThreadLocalMap#set(ThreadLocal, Object)
    

    调用set() 时，会把当前 threadLocal  对象作为 key，想要保存的对象作为 value，存入 map。用于增加或覆盖节点，类似于Map接口的put方法。
    

    1.  
    2. private void set(ThreadLocal key, Object value) { 
    3.  Entry[] tab = table; 
    4.  int len = tab.length; 
    5.  // 计算 key 在数组中的下标 
    6.  int i = key.threadLocalHashCode & (len - 1); 
    7.  // 遍历一段连续的元素，以查找匹配的 ThreadLocal 对象 
    8.  for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) { 
    9.   // 获取该哈希值处的ThreadLocal对象 
    10.   ThreadLocal k = e.get(); 
    11.  
    12.   // 键值ThreadLocal匹配，直接更改map中的value 
    13.   if (k == key) { 
    14.    e.value = value; 
    15.    return; 
    16.   } 
    17.  
    18.   // 若 key 是 null，说明 ThreadLocal 被清理了，直接替换掉 
    19.   if (k == null) { 
    20.    replaceStaleEntry(key, value, i); 
    21.    return; 
    22.   } 
    23.  } 
    24.  
    25.  // 直到遇见了空槽也没找到匹配的ThreadLocal对象，那么在此空槽处安排ThreadLocal对象和缓存的value 
    26.  tab[i] = new Entry(key, value); 
    27.  int sz = ++size; 
    28.  // 进行启发式擦除，节点数量大于阈值。如果右节点擦除成功，节点数量不可能大于阈值 
    29.  if (!cleanSomeSlots(i, sz) && sz >= threshold) { 
    30.   // 扩容的过程也是对所有的 key 重新哈希的过程 
    31.   rehash(); 
    32.  } 
    33. } 
    

     我们依次来看看调用的几个方法：
    

    1.ThreadLocalMap#replaceStaleEntry(ThreadLocal, Object, int)
    

    1. private void replaceStaleEntry(ThreadLocal key, Object value, 
    2.                                 int staleSlot) { 
    3.      Entry[] tab = table; 
    4.      int len = tab.length; 
    5.      Entry e; 
    6.  
    7.      // Back up to check for prior stale entry in current run. 
    8.      // We clean out whole runs at a time to avoid continual 
    9.      // incremental rehashing due to garbage collector freeing 
    10.      // up refs in bunches (i.e., whenever the collector runs). 
    11.      int slotToExpunge = staleSlot; 
    12.      for (int i = prevIndex(staleSlot, len); 
    13.           (e = tab[i]) != null; 
    14.           i = prevIndex(i, len)) 
    15.          if (e.get() == null) 
    16.              slotToExpunge = i; 
    17.  
    18.      // Find either the key or trailing null slot of run, whichever 
    19.      // occurs first 
    20.      for (int i = nextIndex(staleSlot, len); 
    21.           (e = tab[i]) != null; 
    22.           i = nextIndex(i, len)) { 
    23.          ThreadLocal k = e.get(); 
    24.  
    25.          // If we find key, then we need to swap it 
    26.          // with the stale entry to maintain hash table order. 
    27.          // The newly stale slot, or any other stale slot 
    28.          // encountered above it, can then be sent to expungeStaleEntry 
    29.          // to remove or rehash all of the other entries in run. 
    30.          if (k == key) { 
    31.              e.value = value; 
    32.  
    33.              tab[i] = tab[staleSlot]; 
    34.              tab[staleSlot] = e; 
    35.  
    36.              // Start expunge at preceding stale entry if it exists 
    37.              if (slotToExpunge == staleSlot) 
    38.                  slotToExpunge = i; 
    39.              cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); 
    40.              return; 
    41.          } 
    42.  
    43.          // If we didn't find stale entry on backward scan, the 
    44.          // first stale entry seen while scanning for key is the 
    45.          // first still present in the run. 
    46.          if (k == null && slotToExpunge == staleSlot) 
    47.              slotToExpunge = i; 
    48.      } 
    49.  
    50.      // If key not found, put new entry in stale slot 
    51.      tab[staleSlot].value = null; 
    52.      tab[staleSlot] = new Entry(key, value); 
    53.  
    54.      // If there are any other stale entries in run, expunge them 
    55.      if (slotToExpunge != staleSlot) 
    56.          cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); 
    57.  } 
    

     slotToExpunge 表示第一个过期节点
    

      
    
    • 从staleSlot向前扫描，扫描到第一个为null的节点截止，如果中间有过期节点，记录扫描过程中遇到的最后一个过期节点的下标为  slotToExpunge;
      • 
    
    • 从staleSlot向后扫描，扫描找到key值对应的节点或null节点截止：如果在 [从staleSlot向前扫描]  中没有找到过期节点，需要本次扫描中遇到的第一个过期节点的下标记录为 slotToExpunge ;如果找到来 key值对应的节点，覆盖后将该节点移到  staleSlot 处，并将该节点的原来的位置作为过期节点处理;如果没有找到节点，新建节点放置到 staleSlot 处。
      • 
    
    • 如果在两次扫描中找到了过期节点，先对该节点进行擦除，并调用启发式扫描擦除。
      • 

    

    总体来说，假如 i 下标处的节点是 staleSlot  节点左边离得最近的null节点，j 下标处的节点是 staleSlot 节点右边离得最近的null节点，并且key值对应的节点作为过期节点处理。
    

    那么该方法的功能就两段：
    

      
    
    • 将 key、value 组成节点放到 staleSlot 处;
      • 
    
    • 如果在(i —  j)的序列中扫描到了过期节点，那么擦除该节点，并从该节点后的第一个null节点开始启发式擦除。
      • 

    

    之所以需要向前扫描，是为了避免在扫描过程中对有效节点的rehash后出现由过期节点导致的hash冲突。
    

    2.ThreadLocalMap#rehash()
    

    1. private void rehash() { 
    2.  expungeStaleEntries(); 
    3.  
    4.     // Use lower threshold for doubling to avoid hysteresis 
    5.  if (size >= threshold - threshold / 4) 
    6.   resize(); 
    7. } 
    

     启动全局扫描擦除，擦除后再次判断是否需要扩容。之所以叫做rehash，可以理解成在全局扫描中所有的有效节点都需要重新hash确定位置。可以看到，并不是节点数量大于阈值后就会触发扩容，只有全局扫描擦除后数量仍大于阈值的3/4(容量的1/2)才会进行扩容。
    

    3.ThreadLocalMap#resize()
    

    1.  
    2. private void resize() { 
    3.  Entry[] oldTab = table; 
    4.  int oldLen = oldTab.length; 
    5.     // 新建一个数组，按照2倍长度扩容 
    6.  int newLen = oldLen * 2; 
    7.  Entry[] newTab = new Entry[newLen]; 
    8.  int count = 0; 
    9.  // 将旧数组的值拷贝到新数组上 
    10.  for (int j = 0; j < oldLen; ++j) { 
    11.   Entry e = oldTab[j]; 
    12.   if (e != null) { 
    13.    ThreadLocal k = e.get(); 
    14.             // 若有垃圾值，则标记清理该元素的引用，以便GC回收 
    15.    if (k == null) { 
    16.     e.value = null; // Help the GC 
    17.    } else { 
    18.                 // 计算 ThreadLocal 在新数组中的位置 
    19.     int h = k.threadLocalHashCode & (newLen - 1); 
    20.                 如果发生冲突，使用线性探测往后寻找合适的位置 
    21.     while (newTab[h] != null) 
    22.      h = nextIndex(h, newLen); 
    23.                     newTab[h] = e; 
    24.                     count++; 
    25.                 } 
    26.             } 
    27.  } 
    28.  // 设置新的扩容阀值，为数组成都的三分之二 
    29.  setThreshold(newLen); 
    30.  size = count; 
    31.  table = newTab; 
    32. } 
    

     建立新数组，容量为原来的2倍，遍历数组中的元素，将有效节点hash后放入新数组，设置threshold，size等属性。
    

    ThreadLocal的 remove 方法
    

    remove 方法源码如下所示：
    

    1.  
    2. public void remove() { 
    3.  // 返回当前线程持有的 map 
    4.  ThreadLocalMap m = getMap(Thread.currentThread()); 
    5.  if (m != null) { 
    6.   // 从 map 中清理当前 ThreadLocal 对象关联的键值对 
    7.   m.remove(this); 
    8.  } 
    9. } 
    

     remove 方法的时序图如下所示：
    


    

    

    remove 方法是先获取到当前线程的 ThreadLocalMap，并且调用了它的 remove 方法，从 map 中清理当前 ThreadLocal  对象关联的键值对，这样 value 就可以被 GC 回收了。
    

    ThreadLocal的 set 方法
    

    set 方法源码如下：
    

    1.  
    2. public void set(T value) { 
    3.  // 返回当前ThreadLocal所在的线程 
    4.  Thread t = Thread.currentThread(); 
    5.  // 返回当前线程持有的map 
    6.  ThreadLocalMap map = getMap(t); 
    7.  if (map != null) { 
    8.   // 如果 ThreadLocalMap 不为空，则直接存储键值对 
    9.   map.set(this, value); 
    10.  } else { 
    11.   // 否则，需要为当前线程初始化 ThreadLocalMap，并存储键值对  
    12.   createMap(t, value); 
    13.  } 
    14. } 
    

     set 方法的作用是把我们想要存储的  value 给保存进去。其主要流程为：
    

      
    
    1. 先获取当当前线程的引用;
      2. 
    
    2. 利用这个引用来获取到 ThreadLocalMap;
      3. 
    
    3. 如果  map 为空，则去创建一个 ThreadLocalMap;
      4. 
    
    4. 如果 map 不为空，就利用 ThreadLocalMap 的 set 方法将  value 添加到 map 中。
      5. 

    

      
    
    • 其中 map 就是 ThreadLocalMap。
      • 

    

    调用 ThreadLocalMap.set()  时，会把当前 threadLocal 对象作为 key，想要保存的对象作为 value，存入 map。
    

    set 方法的时序图如下所示：
    

     
    

    ThreadLocal的 getMap 方法
    

    1.  
    2. ThreadLocalMap getMap(Thread t) { 
    3.  return t.threadLocals; 
    4. } 
    

     getMap 方法的作用主要是获取当前线程内的 ThreadLocalMap 对象，原来这个 ThreadLocalMap  是线程Thread类的一个属性，我们来看看 Thread 中相关的代码：
    

    1.  
    2. ThreadLocal.ThreadLocalMap threadLocals = null; 
    

     ThreadLocal的 get 方法
    

    get 方法源码如下：
    

    1.  
    2. public T get() { 
    3.  // 返回当前 ThreadLocal 所在的线程 
    4.  Thread t = Thread.currentThread(); 
    5.  // 从线程中拿到 ThreadLocalMap 
    6.  ThreadLocalMap map = getMap(t); 
    7.  if (map != null) { 
    8.   // 从 map 中拿到 entry 
    9.   ThreadLocalMap.Entry e = map.getEntry(this); 
    10.   // 如果不为空，读取当前 ThreadLocal 中保存的值 
    11.   if (e != null) { 
    12.    @SuppressWarnings("unchecked") 
    13.    T result = (T) e.value; 
    14.    return result; 
    15.   } 
    16.  } 
    17.  // 若 map 为空，则对当前线程的 ThreadLocal 进行初始化，最后返回当前的 ThreadLocal 对象关联的初值，即 value 
    18.  return setInitialValue(); 
    19. } 
    

     get  方法的主要流程为：
    

      
    
    1. 先获取到当前线程的引用;
      2. 
    
    2. 获取当前线程内部的 ThreadLocalMap;
      3. 
    
    3. 如果 map  存在，则获取当前 ThreadLocal 对应的 value 值;
      4. 
    
    4. 如果 map 不存在或者找不到 value 值，则调用  setInitialValue() 进行初始化。
      5. 

    

    get 方法的时序图如下所示：
    


    

    

    其中每个 Thread 的 ThreadLocalMap 以 threadLocal 作为 key，保存自己的线程的  value副本，也就是保存在每个线程中，并没有保存在 ThreadLocal 对象中。
    

    小结
    

    通过对源码的分析，现在我们来总结一下：
    

      
    
    1. 每个Thread维护着一个ThreadLocalMap的引用;
      2. 
    
    2. ThreadLocalMap是ThreadLocal的内部类，用Entry来进行存储;
      3. 
    
    3. ThreadLocal创建的副本是存储在自己的threadLocals中的，也就是自己的ThreadLocalMap;
      4. 
    
    4. ThreadLocalMap的键值为ThreadLocal对象，而且可以有多个threadLocal变量，因此保存在map中;
      5. 
    
    5. 在进行get之前，必须先set，否则会报空指针异常，当然也可以初始化一个，但是必须重写initialValue()方法;
      6. 
    
    6. ThreadLocal本身并不存储值，它只是作为一个key来让线程从ThreadLocalMap获取value。
      7. 

    

    ThreadLocal  应用场景
    

    ThreadLocal 的特性也导致了应用场景比较广泛，主要的应用场景如下：
    

      
    
    • 线程间数据隔离，各线程的 ThreadLocal  互不影响
      • 
    
    • 方便同一个线程使用某一对象，避免不必要的参数传递
      • 
    
    • 全链路追踪中的 traceId 或者流程引擎中上下文的传递一般采用  ThreadLocal
      • 
    
    • Spring 事务管理器采用了 ThreadLocal
      • 
    
    • Spring MVC 的  RequestContextHolder 的实现使用了 ThreadLocal
      • 

    

    总结：面试常见问题
    

    Thread、ThreadLocal  以及 ThreadLocalMap关系
    

    通过对以上源码的分析，Thread、ThreadLocal 以及 ThreadLocalMap  的关系有了进一步的理解，我们再通过一张图来总结下:
    


    

    

    ThreadLocal 是如何实现线程隔离的呢?
    

    ThreadLocal 是如何做到线程数据隔离，前面源码分析 ThreadLocal 的  set 方法已经分析过，这里我们再总结一下：
    

    ThreadLocal之所以能达到变量的线程隔离，其实就是每个线程都有一个自己的ThreadLocalMap对象来存储同一个threadLocal实例set的值，而取值的时候也是根据同一个threadLocal实例去自己的ThreadLocalMap里面找，自然就互不影响了，从而达到线程隔离的目的。如下图所示：
    


    

    

    ThreadLocal内存泄漏问题
    

    ThreadLocal 在没有外部强引用时，发生 GC时会被回收，那么 ThreadLocalMap  中保存的 key 值就变成了 null，而 Entry 又被 threadLocalMap 对象引用，threadLocalMap 对象又被 Thread  对象所引用，那么当 Thread 一直不终结的话，value 对象就会一直存在于内存中，也就导致了内存泄漏，直至 Thread  被销毁后，才会被回收。我们通过一张图来理解下：
    


    

    

    ThreadLocal内存泄漏的根源是：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key就会导致内存泄漏，而不是因为弱引用。
    

    那么如何避免内存泄漏呢?
    

    在使用完 ThreadLocal 变量后，需要我们手动 remove 掉，防止 ThreadLocalMap 中的  Entry 一直保持对 value 的强引用，导致 value 不能被回收。
    

    PS：以上代码提交在 Github ：
    

    https://github.com/Niuh-Study/niuh-juc-final.git
    

     【编辑推荐】
    



     
    来源：今日头条内容投诉
    免责声明：
    ① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。 
    ② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
    软考中级精品资料免费领 
    • 历年真题答案解析
    • 备考技巧名师总结
    • 高频考点精准押题
    • 资料下载
    • 历年真题
    • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）
       难度      813人已做 
       查看 
    • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析
       难度      354人已做 
       查看 
    • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析
       难度      318人已做 
       查看 
    • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）
       难度      435人已做 
       查看 
    • 2024年上半年系统架构设计师考试综合知识真题
       难度      224人已做 
       查看 
    相关文章
    发现更多好内容
    猜你喜欢
    AI推送时光机
    并发编程之ThreadLocal深入理解
    后端开发编程ThreadLocal2024-12-03
    深入理解Java并发编程之ThreadLocal
    后端开发2022-11-13
    并发编程之Synchronized深入理解
    后端开发Synchronized2024-12-03
    Java并发编程之ThreadLocal详解
    后端开发2024-04-02
    Java并发编程之threadLocal
    后端开发2024-04-02
    深入理解Java并发编程之LinkedBlockingQueue队列
    后端开发2024-04-02
    java并发编程之深入理解Synchronized的使用
    后端开发2024-04-02
    # 深入理解高并发编程（二）
    后端开发2023-09-26
    并发编程之Future&FutureTask深入解析
    后端开发Future&FutureTask编程2024-12-03
    深入理解并发编程艺术之JVM内存模型
    后端开发Java语言2024-11-30
    深入了解Python并发编程
    后端开发2024-04-02
    Java并发编程之阻塞队列深入详解
    后端开发2024-04-02
    深入理解并发编程同步工具类
    后端开发并发编程同步2024-12-01
    深入理解并发编程艺术之计算机内存模型
    后端开发计算机内存2024-11-30
    Java并发编程之关键字volatile的深入解析
    后端开发2024-04-02
    深入理解并发编程中的三个问题
    后端开发线程开发2024-11-30
    Java并发编程深入理解之Synchronized的使用及底层原理详解 上
    后端开发2024-04-02
    深入理解高并发编程 - 深度解析Thread 类的源码
    后端开发2023-09-08
    Java并发编程深入理解之Synchronized的使用及底层原理详解 下
    后端开发2024-04-02
    深入理解Go语言的并发编程：Go的并发模型解析
    深入理解Go语言的并发编程：Go的并发模型解析
    后端开发2024-03-04
     位置：首页-资讯-后端开发
     咦！没有更多了？去看看其它编程学习网 内容吧 
    首页课程
    资料下载    问答资讯