登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›Java源码分析系列笔记-14.ThreadPool

Java源码分析系列笔记-14.ThreadPool

舒菀菀 2025-6-26 17:38:48
目录

  • 1. 是什么
  • 2. 如何使用
  • 3. 原理分析

    • 3.1. uml
    • 3.2. 构造方法
    • 3.3. set方法

      • 3.3.1. 先获取Thread对应的ThreadLocalMap
      • 3.3.2. 有的话调用ThreadLocalMap set方法插入ThreadLocal:value

        • 3.3.2.1. 发生Hash冲突则使用开放寻址法

      • 3.3.3. 没有则创建ThreadLocalMap并放入ThreadLocal:value

        • 3.3.3.1. ThreadLocalMap构造方法


    • 3.4. get方法

      • 3.4.1. 先获取Thread对应的ThreadLocalMap
      • 3.4.2. Map不为空，那么从Map中获取key为当前ThreadLocal对象的Entry

        • 3.4.2.1. 使用开放寻址法继续寻找下一个位置

      • 3.4.3. Map为空，则向创建后初始化默认值Null

    • 3.5. remove方法

      • 3.5.1. 先获取Thread对应的ThreadLocalMap
      • 3.5.2. 通过ThreadLocalMap remove key为当前ThreadLocal的Entry


  • 4. 总结
  • 5. 参考

1. 是什么

不是线程同步机制，是一种线程数据隔离机制。
多线程共享变量通信的情况下，我们需要保证线程安全。一种方法是使用锁，另一种就是数据隔离机制。
ThreadLocal用的是后一种，即每个线程操作的是自己独有的数据，因此互相之间不会影响
2. 如何使用
  1. public class ThreadLocalTest
  2. {
  3.     public static void main(String[] args) throws InterruptedException
  4.     {
  5.         ThreadLocal<String> threadLocal = new ThreadLocal<>();
  6.         threadLocal.set("main");
  7.         System.out.println(Thread.currentThread().getName() + ":" + threadLocal.get());//main:main
  9.         Thread thread1 = new Thread(()->{
  10.             threadLocal.set("thread1");
  11.             System.out.println(Thread.currentThread().getName() + ":" + threadLocal.get());//Thread-0:thread1
  12.         });
  14.         Thread thread2 = new Thread(()->{
  15.             threadLocal.set("thread2");
  16.             System.out.println(Thread.currentThread().getName() + ":" + threadLocal.get());//Thread-1:thread2
  17.         });
  19.         thread1.start();
  20.         thread2.start();
  22.         thread1.join();
  23.         thread2.join();
  25.         System.out.println(Thread.currentThread().getName() + ":" + threadLocal.get());//main:main
  27.         threadLocal.remove();
  29.         System.out.println(Thread.currentThread().getName() + ":" + threadLocal.get());//main:null
  32.     }
  33. }
复制代码
3. 原理分析

3.1. uml

1.png

Thread有一个ThreadLocalMap属性，
ThreadLocalMap有一个Entry数组属性
Entry有key和value属性，其中key为ThreadLocal，value为Object。并且Entry继承了WeakReference
3.2. 构造方法
  1. //记录hash值
  2. private static AtomicInteger nextHashCode =
  3.         new AtomicInteger();
  5. public ThreadLocal() {
  6. }
复制代码
3.3. set方法
  1. public void set(T value) {
  2.     Thread t = Thread.currentThread();
  3.     //获取当前线程对应的ThreadLocalMap属性
  4.     ThreadLocalMap map = getMap(t);
  5.     if (map != null)
  6.             //将（ThreadLocal，value）构造成Entry放入ThreadLocalMap
  7.         map.set(this, value);
  8.     else
  9.             //创建新的map关联当前线程，并且并放入（ThreadLocal，value）
  10.         createMap(t, value);
  11. }
复制代码

  • 4行：先获取Thread对应的ThreadLocalMap
  • 5-7行：有的话调用ThreadLocalMap set方法插入ThreadLocal:value
  • 8-10行：没有则创建ThreadLocalMap并放入ThreadLocal:value
下面具体分析：
3.3.1. 先获取Thread对应的ThreadLocalMap
  1. Thread t = Thread.currentThread();
  2. //获取当前线程对应的ThreadLocalMap属性
  3. ThreadLocalMap map = getMap(t);
复制代码

  • getMap
  1. ThreadLocalMap getMap(Thread t) {
  2.         //获取当前Thread对应的ThreadLocalMap对象
  3.     return t.threadLocals;
  4. }
复制代码
3.3.2. 有的话调用ThreadLocalMap set方法插入ThreadLocal:value


  • 调用ThreadLocalMap set
  1. private void set(ThreadLocal<?> key, Object value) {
  3.     Entry[] tab = table;
  4.     int len = tab.length;
  5.            //计算当前元素在数组中的位置
  6.     int i = key.threadLocalHashCode & (len-1);
  8.         //如果key不在数组中，那么一直找到空位置
  9.     for (Entry e = tab[i];
  10.          e != null;
  11.              //开放寻址法
  12.          e = tab[i = nextIndex(i, len)]) {
  13.         ThreadLocal<?> k = e.get();
  15.                 //key相等，替换值
  16.         if (k == key) {
  17.             e.value = value;
  18.             return;
  19.         }
  21.                 //key为空，那么构造entry放入
  22.         if (k == null) {
  23.             replaceStaleEntry(key, value, i);
  24.             return;
  25.         }
  26.     }
  28.         //走到这里说明退出循环，找到了空位置
  29.     tab[i] = new Entry(key, value);
  30.     int sz = ++size;
  31.     //是否需要扩容
  32.     if (!cleanSomeSlots(i, sz) && sz >= threshold)
  33.         rehash();
  34. }
复制代码
3.3.2.1. 发生Hash冲突则使用开放寻址法


  • nextIndex
  1. private static int nextIndex(int i, int len) {
  2.         //线性探测i+1的位置
  3.     return ((i + 1 < len) ? i + 1 : 0);
  4. }
复制代码
3.3.3. 没有则创建ThreadLocalMap并放入ThreadLocal:value
  1. else
  2.     //创建新的map关联当前线程，并且并放入（ThreadLocal，value）
  3.     createMap(t, value);
复制代码

  • createMap
  1. void createMap(Thread t, T firstValue) {
  2.         //当前ThreadLocal对象作为key，value作为value构造entry并构造map
  3.         //thread的ThreadLocalMap属性是这里设置的
  4.     t.threadLocals = new ThreadLocalMap(this, firstValue);
  5. }
复制代码
3.3.3.1. ThreadLocalMap构造方法
  1. static class ThreadLocalMap {
  3.         //由于Entry继承了WeakRefence
  4.         static class Entry extends WeakReference<ThreadLocal<?>> {
  5.                 Object value;
  7.                 Entry(ThreadLocal<?> k, Object v) {
  8.                 //key是个弱引用（即一旦发生垃圾回收就会回收这个引用指向的对象）。
  9.                 //当key被回收后，也即ThreadLocal被回收了，但是Entry中value的引用还在无法回收，可能会造成内存泄漏
  10.                     super(k);
  11.                     value = v;
  12.                 }
  13.         }
  15.         //初始容量为16，必须为2的次方
  16.         private static final int INITIAL_CAPACITY = 16;
  18.         //使用数组+线性探测法
  19.         private Entry[] table;
  21.         //实际使用的长度
  22.         private int size = 0;
  24.         //实际使用的长度达到这个长度时需要扩容
  25.         private int threshold;
  26.        
  27.         ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
  28.                 table = new Entry[INITIAL_CAPACITY];
  29.                 //计算下标并且存入entry
  30.                 int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
  31.                 table[i] = new Entry(firstKey, firstValue);
  32.                
  33.                 size = 1;
  34.                 setThreshold(INITIAL_CAPACITY);//设置threshold为16*2/3=10
  35.         }
  37.         private void setThreshold(int len) {
  38.         threshold = len * 2 / 3;
  39.     }
复制代码
3.4.3. Map为空，则向创建后初始化默认值Null


  • setInitialValue
  1. public T get() {
  2.     Thread t = Thread.currentThread();
  3.     //获取当前线程对应的ThreadLocalMap
  4.     ThreadLocalMap map = getMap(t);
  5.     if (map != null) {
  6.             //以当前ThreadLocal对象作为key从ThreadLocalMap中获取entry
  7.         ThreadLocalMap.Entry e = map.getEntry(this);
  8.             //从entry中获取value并返回       
  9.         if (e != null) {
  10.             @SuppressWarnings("unchecked")
  11.             T result = (T)e.value;
  12.             return result;
  13.         }
  14.     }
  15.     //初始化map
  16.     return setInitialValue();
  17. }
复制代码
3.5. remove方法
  1. Thread t = Thread.currentThread();
  2. //获取当前线程对应的ThreadLocalMap属性
  3. ThreadLocalMap map = getMap(t);
复制代码

  • 3行：先获取Thread对应的ThreadLocalMap
  • 4-5行：通过ThreadLocalMap remove key为当前ThreadLocal的Entry
3.5.1. 先获取Thread对应的ThreadLocalMap
  1. ThreadLocalMap getMap(Thread t) {
  2.         //获取当前Thread对应的ThreadLocalMap对象
  3.     return t.threadLocals;
  4. }
复制代码

  • getMap
  1. ThreadLocalMap getMap(Thread t) {
  2.         //获取当前Thread对应的ThreadLocalMap对象
  3.     return t.threadLocals;
  4. }
复制代码
3.5.2. 通过ThreadLocalMap remove key为当前ThreadLocal的Entry
  1. private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
  2.     Entry[] tab = table;
  3.     int len = tab.length;
  5.         //一直线性探测到为null（不存在）
  6.     while (e != null) {
  7.         ThreadLocal<?> k = e.get();
  8.         //key是否相等
  9.         if (k == key)
  10.             return e;
  11.         //ThreadLocal被回收了，那么回收value对象
  12.         if (k == null)
  13.             expungeStaleEntry(i);
  14.         else//继续下一个
  15.             i = nextIndex(i, len);
  16.         e = tab[i];
  17.     }
  18.    
  19.     return null;
  20. }
复制代码
}
4. 总结


  • 每个Thread都有ThreadLocalMap属性。可以想象成一个HashMap，这个Map中Entry 的key为ThreadLocal，value为要存储的值
  • 由于key为ThreadLocal自己，因此一个ThreadLocal只能存储一个Object对象，如果需要存储多个Object对象那么就需要多个ThreadLocal
  • 由于Entry继承了WeakRefence，key是个弱引用（即一旦发生垃圾回收就会回收这个引用指向的对象）。当key被回收后，也即ThreadLocal被回收了，但是Entry中value的引用还在无法回收，可能会造成内存泄漏。因此我们需要用static引用ThreadLocal变量且手动remove
5. 参考


  • 手撕面试题ThreadLocal！！！ | 并发编程网 – ifeve.com
  • Java面试必问，ThreadLocal终极篇 - 掘金
  • ThreadLocal内存泄漏问题 - 掘金

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
Java源码分析Java源码

使用道具 举报

相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
舒菀菀
2025-6-26 17:38:48

0

粉丝关注

9

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫