程序博客网 > 兴义网络

ThreadLocal源码分析（JDK8）

来源：互联网 发布：兴义网络 编辑：程序博客网 时间：2024/05/22 17:23

ThreadLocal源码分析（JDK8）

分类：
作者同类文章X
    作者同类文章X

      版权声明：【分享也是一种提高】个人转载请在正文开头明显位置注明出处，未经作者同意禁止企业/组织转载，禁止私自更改原文，禁止用于商业目的。

      ThreadLocal特性及使用场景：
      1、方便同一个线程使用某一对象，避免不必要的参数传递；
      2、线程间数据隔离（每个线程在自己线程里使用自己的局部变量，各线程间的ThreadLocal对象互不影响）；
      3、获取数据库连接、Session、关联ID（比如日志的uniqueID，方便串起多个日志）；

      ThreadLocal应注意：
      1、ThreadLocal并未解决多线程访问共享对象的问题；
      2、ThreadLocal并不是每个线程拷贝一个对象，而是直接new（新建）一个；
      3、如果ThreadLocal.set()的对象是多线程共享的，那么还是涉及并发问题。
      1、ThreadLocal<T>初始化
      private final int threadLocalHashCode = nextHashCode();
      private static final intHASH_INCREMENT=0x61c88647;
      /**
      * The next hash code to be given out. Updated atomically.Starts at zero.
      */
      // 源码说nextHashCode初始值为0，但实际调试时显示初始值为1253254570，费解？
      // 而且当初始化完毕后，nextHashCode的值又变为0，说明其初始值确实是0的。
      private static AtomicInteger nextHashCode = new AtomicInteger();  private static intnextHashCode() {      return nextHashCode.getAndAdd(HASH_INCREMENT);  }


      ThreadLocal类变量有3个，其中2个是静态变量（包括一个常量），实际作为作为ThreadLocal实例的变量只有threadLocalHashCode这1个，而且已经初始化就不可变了。
      创建ThreadLocal实例时有哪些操作呢：
      ThreadLocal初始化时会调用nextHashCode()方法初始化threadLocalHashCode，且threadLocalHashCode初始化后不可变。threadLocalHashCode可用来标记不同的ThreadLocal实例。

      2、内部类
      2.1 ThreadLocalMap
      ThreadLocalMap是定制的hashMap，仅用于维护当前线程的本地变量值。仅ThreadLocal类对其有操作权限，是Thread的私有属性。为避免占用空间较大或生命周期较长的数据常驻于内存引发一系列问题，hash table的key是弱引用WeakReferences。当空间不足时，会清理未被引用的entry。
      ThreadLocalMap中的重点：
      static class Entryextends WeakReference<ThreadLocal<?>>{     /** The value associated with this ThreadLocal. */      Object value;       Entry(ThreadLocal<?> k, Object v){         super(k);          value= v;     }  }


      Note：
      ThreadLocalMap的key是ThreadLocal，value是Object（即我们所谓的“线程本地数据”）。

      2.2 SuppliedThreadLocal<T> extends ThreadLocal<T>
      SuppliedThreadLocal是JDK8新增的内部类，只是扩展了ThreadLocal的初始化值的方法而已，允许使用JDK8新增的Lambda表达式赋值。需要注意的是，函数式接口Supplier不允许为null。
      源码如下：
      static final class SuppliedThreadLocal<T>extends ThreadLocal<T>{      private final Supplier<?extends T> supplier;       SuppliedThreadLocal(Supplier<?extends T> supplier){         this.supplier= Objects.requireNonNull(supplier);     }       @Override     protected T initialValue(){         return supplier.get();     }  }


      3、主要方法
      3.1、T get()
      返回当前线程的value。
      [java] view plain copy
      print?在CODE上查看代码片派生到我的代码片
      1. public T get(){  
      2.     Thread t= Thread.currentThread(); // 获取当前线程  
      3.     ThreadLocalMap map= getMap(t); // 获取当前线程对应的Map  
      4.    if(map!=null){  
      5.         ThreadLocalMap.Entry e = map.getEntry(this); // 详见3.1.1  
      6.        if(e!=null){ // map不为空且当前线程有value，返回value  
      7.             @SuppressWarnings("unchecked")  
      8.             T result=(T)e.value;  
      9.            return result;  
      10.        }  
      11.    }  
      12.    return setInitialValue(); // 初始化再返回值  
      13. }  
      -----
      getMap的源码：
      [java] view plain copy
      print?在CODE上查看代码片派生到我的代码片
      1. ThreadLocalMap getMap(Thread t){  
      2.    returnt.threadLocals;  
      3. }  
      getMap(t)返回当前线程的成员变量ThreadLocalMap（Thread的成员变量有ThreadLocalMap，这一点可以查看Thread的源码，如下）很明确的说明了ThreadLocal属于线程，ThreadLocalMap由ThreadLocal持有，说到底，ThreadLocalMap 也是线程所持有。每个线程Thread都有自己的ThreadLocalMap。
      /* ThreadLocal values pertaining to this thread. This map is maintained by the ThreadLocal class. */
      ThreadLocal.ThreadLocalMap threadLocals = null;

      --------
      setInitialValue源码：
      [java] view plain copy
      print?在CODE上查看代码片派生到我的代码片
      1. private T setInitialValue(){  
      2.     T value= initialValue(); //调用重写的initialValue，返回新值  
      3.     Thread t= Thread.currentThread();  
      4.     ThreadLocalMap map= getMap(t);  
      5.    if(map!=null) // 当前线程的ThreadLocalMap不为空，则直接赋值  
      6.         map.set(this, value);  
      7.    else  
      8. // 为当前线程创造一个ThreadLocalMap(this, firstValue)并赋初值，this为当前线程  
      9.         createMap(t, value);  
      10.    return value;  
      11. }  
      12. protected T initialValue() {  
      13.     return T; // 自定义返回值  
      14. };  
      createMap源码：
      [java] view plain copy
      print?在CODE上查看代码片派生到我的代码片
      1. void createMap(Thread t, T firstValue){  
      2.     t.threadLocals=new ThreadLocalMap(this, firstValue);  
      3. }  
      ThreadLocal之get流程：
      1、获取当前线程t；
      2、返回当前线程t的成员变量ThreadLocalMap（以下简写map）；
      3、map不为null，则获取以当前线程为key的ThreadLocalMap的Entry（以下简写e），如果e不为null，则直接返回该Entry的value；
      4、如果map为null或者e为null，返回setInitialValue()的值。setInitialValue()调用重写的initialValue()返回新值（如果没有重写initialValue将返回默认值null），并将新值存入当前线程的ThreadLocalMap（如果当前线程没有ThreadLocalMap，会先创建一个）。

      3.2、void set(T value)
      为【当前线程】的【当前ThreadLocal】赋值（初始值or新值）。和setInitialValue相当相似，就不多分析了。
      [java] view plain copy
      print?在CODE上查看代码片派生到我的代码片
      1. public void set(T value){  
      2.     Thread t= Thread.currentThread();  
      3.     ThreadLocalMap map= getMap(t);  
      4.    if(map!=null)  
      5.         map.set(this, value);  
      6.    else  
      7.         createMap(t, value);  
      8. }  
      3.3、void remove()
      获取当前线程的ThreadLocalMap，map不为空，则移除当前ThreadLocal作为key的键值对。
      [java] view plain copy
      print?在CODE上查看代码片派生到我的代码片
      1. public void remove(){  
      2.      ThreadLocalMap m= getMap(Thread.currentThread());  
      3.     if(m!=null)  
      4.          m.remove(this);  
      5.  }  
      Note：
      remove()移除当前线程的当前ThreadLocal数据（只是清空该key-value键值对），而且是立即移除，移除后，再调用get方法将重新调用initialValue方法初始化（除非在此期间调用了set方法赋值）。

      3.4、static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier)
      JDK8新增，支持Lambda表达式，和ThreadLocal重写的initialValue()效果一样。
      [java] view plain copy
      print?在CODE上查看代码片派生到我的代码片
      1. public static<S> ThreadLocal<S> withInitial(Supplier<?extends S> supplier){  
      2.    return new SuppliedThreadLocal<>(supplier);  
      3. }  
      可以看出，withInitial()方法的入参是函数式接口Supplier，返回值是JDK8新增的内部类SuppliedThreadLocal，正如2.2所说，区别仅在于支持Lambda表达式赋值而已。使用事例如下：
      [java] view plain copy
      print?在CODE上查看代码片派生到我的代码片
      1. @Test  
      2. public void jdk8Test(){  
      3.     Supplier<String> supplier =new Supplier<String>(){  
      4.          @Override  
      5.        public String get(){  
      6.            return"supplier_new";  
      7.        }  
      8.    };  
      9.     threadLocal= ThreadLocal.withInitial(supplier);  
      10.     System.out.println(threadLocal.get());// supplier_new  
      11.     threadLocal= ThreadLocal.withInitial(()->"sup_new_2");  
      12.     System.out.println(threadLocal.get());// sup_new_2  
      13.     ThreadLocal<DateFormat> localDate = ThreadLocal.withInitial(()->new SimpleDateFormat("yyyy-MM-dd"));  
      14.     System.out.println(localDate.get().format(new Date()));// 2017-01-22  
      15.     ThreadLocal<String> local =new ThreadLocal<>().withInitial(supplier);  
      16.     System.out.println(local.get());// supplier_new  
      17. }  
      Note：
      ·withInitial(supplier)是有返回值ThreadLocal的，So实例化时需将其赋值给ThreadLocal实例。
      4、图解ThreadLocal
      每个线程可能有多个ThreadLocal，同一线程的各个ThreadLocal存放于同一个ThreadLocalMap中。

      图解ThreadLocal(JDK8).vsdx原图下载地址：https://github.com/zxiaofan/JDK-Study/tree/master/src/java1/lang/threadLocal

      5、ThreadLocal-ThreadLocalMap源码分析

      5.1、Entry getEntry(ThreadLocal<?> key)
      首先来看get方法，你会发现ThreadLocalMap的get方法和传统Map不同，其返回的不是key-value的value，而是整个entry，当时entry的key是ThreadLocal，value是存放的值，这点是一致的。
      a、getEntry源码分析：
      [java] view plain copy
      print?在CODE上查看代码片派生到我的代码片
      1. private Entry getEntry(ThreadLocal<?> key){  
      2.    int i= key.threadLocalHashCode&(table.length-1);  
      3.     Entry e= table[i];  
      4.    if(e!=null&& e.get()== key)  
      5.        return e;  
      6.    else  
      7.        return getEntryAfterMiss(key, i, e);  
      8. }  
      getEnrty方法只会处理key被直接命中的entry，没有直接命中的（key冲突的）数据将调用getEntryAfterMiss()方法返回对应enrty，按照源码解释，这样做是为了尽可能提升直接命中的性能。
      ThreadLocalMap之getEntry的流程：
      1、计算Entry数组的index（(length - 1) & key.hash）。
      索引计算和HashMap的异同：
      ①相似之处：计算方式相同，均为(length - 1) & key.hash;length均为底层结构的大小（是大小，不是实际size）。
      ②不同之处：HashMap（JDK8）底层数据结构是位桶+链表/红黑树，而ThreadLocalMap底层数据结构是Entry数组；HashMap的key.hash的计算方式是native、异或、无符号位移，(key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16)，ThreadLocalMap的key.hash从ThreadLocal实例化时便由nextHashCode()确定。
      2、获取对应index的节点Entry；
      3、如果返回节点entry 有值且其key未冲突（只有1个即entry返回的key等于传入的key），则直接返回该entry；
      4、返回entry为空或键冲突，则调用getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e)方法返回entry。

      b、getEntryAfterMiss源码分析：
      getEntryAfterMiss处理那些getEntry时没有被命中的key（value为空的直接返回null，so更确切的说是命中且有冲突的key）。入参是当前ThreadLocal，key在数组的索引index，以及index对应的键值对。
      [java] view plain copy
      print?在CODE上查看代码片派生到我的代码片
      1. private Entry getEntryAfterMiss(ThreadLocal<?> key,int i, Entry e){  
      2.     Entry[] tab = table;  
      3.    int len= tab.length;  
      4.     while(e!=null){  
      5.         ThreadLocal<?> k = e.get();  
      6.        if(k== key)  
      7.            return e;  
      8.        if(k==null)  
      9.             expungeStaleEntry(i);  
      10.        else  
      11.             i= nextIndex(i, len);  
      12.         e= tab[i];  
      13.    }  
      14.    return null;  
      15. }  
      ThreadLocalMap之getEntryAfterMiss的流程：
      仅分析Entry不为空的情况，
      1、获取entry的key；
      2、如果key一致（内存地址=判断），则返回该entry；
      3、如果key为null，则调用expungeStaleEntry方法擦除该entry；
      4、其他情况则通过nextIndex方法获取下一个索引位置index；
      5、获取新index处的entry，再死循环2/3/4，直到定位到该key返回entry或者返回null。
      [java] view plain copy
      print?在CODE上查看代码片派生到我的代码片
      1. private static int nextIndex(int i,int len){  
      2.    return((i+1< len)? i+1:0); // 把索引加1即可  
      3. }  
      c、expungeStaleEntry源码分析：
      只要key为null均会被擦除，使得对应value没有被引用，方便回收。
      [java] view plain copy
      print?在CODE上查看代码片派生到我的代码片
      1. private int expungeStaleEntry(int staleSlot){  
      2.     Entry[] tab = table;  
      3.    int len= tab.length;  
      4.     // expunge entry at staleSlot  
      5.     tab[staleSlot].value=null; // 擦除当前index处value  
      6.     tab[staleSlot]=null; // 擦除当前index处key  
      7.     size--;  
      8.     // Rehash until we encounter null  
      9.     Entry e;  
      10.    int i;  
      11.    for(i= nextIndex(staleSlot, len); // 计算下一个index  
      12.         (e= tab[i])!=null; // 新index处entry不为空  
      13.          i= nextIndex(i, len)){ // 计算下一个index  
      14.         ThreadLocal<?> k = e.get(); // 获取新key（ThreadLocal）  
      15.        if(k==null){ // key为null，再次置空  
      16.             e.value=null;  
      17.             tab[i]=null;  
      18.             size--;  
      19.        }else{  
      20.            int h= k.threadLocalHashCode&(len-1); // 计算新index  
      21.            if(h!= i){ // index若未变化，说明没有多余的entry了  
      22.                 tab[i]=null;  
      23.                 // Unlike Knuth 6.4 Algorithm R, we must scan until  
      24.                // null because multiple entries could have been stale.  
      25. // 一直扫到最后一个非空位置，将其值置为碰撞处第一个entry。  
      26.                while(tab[h]!=null)  
      27.                     h= nextIndex(h, len);  
      28.                 tab[h]= e;  
      29.            }  
      30.        }  
      31.    }  
      32.    return i;  
      33. }  

      5.2、set(ThreadLocal<?> key, Object value)
      [java] view plain copy
      print?在CODE上查看代码片派生到我的代码片
      1. private void set(ThreadLocal<?> key, Object value){  
      2.     // We don't use a fast path as with get() because it is at  
      3.    // least as common to use set() to create new entries as  
      4.    // it is to replace existing ones, in which case, a fast  
      5.    // path would fail more often than not.  
      6.     Entry[] tab = table;  
      7.    int len= tab.length;  
      8.    int i= key.threadLocalHashCode&(len-1);  
      9.     for(Entry e= tab[i]; e !=null;e= tab[i= nextIndex(i, len)]){  
      10. // 当前index处已有entry  
      11.         ThreadLocal<?> k = e.get();  
      12.         if(k== key){ // key（ThreadLocal）相同，更新value  
      13.             e.value= value;  
      14.            return;  
      15.        }  
      16.         if(k==null){ // 出现过期数据  
      17. // 遍历清洗过期数据并在index处插入新数据，其他数据后移  
      18.             replaceStaleEntry(key, value, i);  
      19.            return;  
      20.        }  
      21.    }  
      22.     tab[i]=new Entry(key, value);  
      23.    int sz=++size;  
      24. // 没有过期数据被清理且实际size超过扩容阈值  
      25.    if(!cleanSomeSlots(i, sz)&& sz>= threshold)  
      26.         rehash();  
      27. }  

      rehash()：
      size：table的实际entry数量；扩容阈值threshold：table.lenrth（默认16）大小的2/3；
      首先调用expungeStaleEntries删除所有过期数据，如果清理数据后size>=threshold的3/4，则2倍扩容。
      ps：阈yù值又叫临界值，是指一个效应能够产生的最低值或最高值。阀fá 控制、开关、把持。

      ThreadLocalMap和HashMap在hash冲突时的解决方案对比：
      HashMap：若冲突则将新数据按链表或红黑树逻辑插入。
      详见《HashMap源码分析（jdk1.8）》
      put(K key, V value)的逻辑：
      1、判断键值对数组tab[]是否为空或为null，是则resize()； 
      2、根据键值key的hashCode()计算hash值得到当前Node的索引i（bucketIndex），如果tab[i]==null【没碰撞】，直接新建节点添加，否则【碰撞】转入3 
      3、判断当前数组中处理hash冲突的方式为红黑树还是链表(check第一个节点类型即可),分别处理。【①是红黑树则按红黑树逻辑插入；②是链表，则遍历链表，看是否有key相同的节点；③有则更新value值，没有则新建节点，此时若链表数量大于阀值8【9个】，则调用treeifyBin方法（此方法先判断table是否为null或tab.length小于64，是则执行resize操作，否则才将链表改为红黑树）。】
      4、如果size+1> threshold则resize。

      ThreadLocalMap：
      1、若指定位置index已有数据entry，逐个遍历entry：
      1.1、若index处key相同，则更新value；
      1.2、若index处key为null，则调用replaceStaleEntry清理过期数据并插入新数据（从index处挨个遍历，直到找到相同key更新value结束，或者一直未找到，则在index处放入new Entry）。replaceStaleEntry遍历时会将entry逐个后移，也就是说set进去的最新entry一定会放在index处，方便get时直接命中。
      2、index处无数据，则放入新entry；随后清理过期数据并判断是否2倍扩容（size>=threshold的3/4）。

      参考资料：
      http://www.cnblogs.com/dolphin0520/p/3920407.html
      有任何问题，欢迎指正探讨。
      0 0
      兴义网络 兴义网络
      原创粉丝点击
      热门IT博客
      nba2016赛季球员数据nba2016赛季球员数据
      mysql datetime 时区mysql datetime 时区
      最短路径问题算法
      jsp上传图片到数据库
      编辑照片大小的软件
      tekla软件多少钱
      翻墙方法 知乎
      java国际化
      淘宝网禁出售有毒
      深度linux u盘安装
      股票交易软件开发
      阿里云服务器干嘛用的
      mac版ps2017快捷键
      lua编辑器 mac
      java web开源项目
      嘉兴华点软件
      华力微电子 知乎
      移动组太软件
      网络大电影点击排名
      spss数据分析实例说明
      热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 有文艺范的词 范家屯房子2018以后有升值吗 霸气超拽超有范的句子 霸气超拽超有范的英文句子 有范app 有范是什么意思 的范 国际范 有文艺范的名字 很有范的英文 就范 老范 大范 小范 塞哈范 个性句子短短的有范 英雄之血有什么用 胳膊上有小红点像血点 人体有多少血 醒来发现被子有血 衅 衅怎么读 衅字怎么读 衅的拼音 三衅三浴 臣以险衅 三衅三沐 三浴三衅 衅读音 寻滋衅事是什么罪 光耀大唐 衅漾茂简 衅怎么读音 衅的读音 车衣有用吗 塑身衣有效果吗 衣字旁字有哪些 隐形车衣有用吗 西北有高楼by穆卿衣 石墨烯暖衣对身体有害吗 塑身衣效果 梦见穿孝衣有什么征兆

      程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里