多线程2一ThreadLocal源代码分析

1、应用场景及作用

-1作用、ThreadLocal 为了实现线程之间数据隔离,每个线程中有独立的变量副本,操作互不干扰。
  区别于线程同步中,同步在为了保证正确使用同一个共享变量,需要加锁。
-2应用场景:
   1)可以对一次请求过程,做一个过程日志追踪。如slf4j的MDC组件的使用,可以在日志中每次请求过程加key,方便定位一次请求流程问题。 
   2)解决线程中全局数据传值问题。

2、结构关系

要理清ThreadLocal的原理作用,可以先了解Thread, ThreadLocal, ThreadLocalMap三者之间的关系。简单类图关系如下

2.1、三者关系类图

多线程2一ThreadLocal源代码分析_第1张图片

1、Thread 类中有ThreadLocalMap类型的成员变量 threadLocals
2、ThreadLocalMap是ThreadLocal的静态内部类 
3、Thread 与 ThreadLocal怎么关联?
   线程对象中threadLocals中存储的键值对 key--> ThreadLocal对象,value --> 线程需要保存的变量值
   

2.2、ThreadLocalMap结构图

多线程2一ThreadLocal源代码分析_第2张图片

ThreadLocalMap 底层实现实质是一个Entry对象数组, 默认容量是16,在存储元素到数组中,自己实现了一个算法来寻址(计算数组下标), 
与Map集合中的HashMap有所不同。 Entry对象中 key是ThreadLocal对象。
误区:在不了解原理前,会想线程之间要实现数据隔离,那这个集合中key应该是Thread对象,
这样在存的时候,以当前线程对象为key,value为要保存的值,
这样在获取的时候,通过线程对象去get获取相应的值。

2.3、 内存引用关系

多线程2一ThreadLocal源代码分析_第3张图片

-1,同一个ThreadLocal对象可被多个线程引用,每个线程之间本地变量副本存储,实现数据独立性,
  可见每个线程内部都有单独的map集合,即使引用的ThreadLocal同一个,value可以不同,如图中ThreadLocal1对象,同时被线程A,B引用作为key
-2,一个线程可以存储多个ThreadLocal,因线程中存储的只能存储同一个ThreadLocal对象一次,
   再次存储相同的Threadlocal对象,因为key相同,会覆盖原来的value,
   value可以是基本数据类型的值,也可以是引用数据类型(如封装的对象)

2.5、存在内存泄漏原因

多线程2一ThreadLocal源代码分析_第4张图片

ThreadLocal对象没有外部强引用后,只存在弱引用,下一次GC会被回收。如下:

多线程2一ThreadLocal源代码分析_第5张图片

-1,上图实线箭头代表强引用,虚线代表弱引用; JVM存在四种引用:强引用,软引用,弱引用,虚引用,弱引用对象,会在下一次GC(垃圾回收)被回收。
-2,上图可见Entry的 Key指向的ThreadLocal对象的引用是弱引用,一旦tl的强引用断开,没有外部的强引用后,在下一次JVM垃圾回收时,ThreadLocal对象被回收了,此时 key--> null,而此时 Entry对象,是有一条强引用链的,th-->
 Thread对象-->ThreadLocalMap--> Entry,可达性性分析是可达的,这时ThreadLocalMap集合,即在数组的某一个索引是有Entry引用的,但是该Entry的key为null,value依然有值,但再也用不了了,这时的Entry称为staleEntry(我理解为失效的Entry),造成内存泄漏。
-3,内存泄漏是指分配的内存,gc回收不了,自己也用不了; 内存溢出,是指内存不够,如有剩余2M内存,这时有一个对象创建需要3M,内存不够,导致溢出。内存泄漏可能会导致内存溢出,因为内存泄漏就会有人占着茅坑不拉屎,可用空间越来越少,gc也回收不了,最终导致内存溢出。
-4,那线程对象被回收了,这条引用链断了就没事了,下次Gc就会把ThreadLocalMap集合中对象全部回收了,就不存在内存泄漏问题了;但开发环境,线程一般会在线程池创建来节约资源,每个线程是被重复使用的,生命周期很长,线程对象长时间是存在内存中的,而ThreadLocalMap和Thread生命周期相同,只有线程结束,它内部持有的ThreadLocalMap对象才会销毁,如下Thread#exit:
  private void exit() {
        if (group != null) {
            group.threadTerminated(this);
            group = null;
        }
        /* Aggressively null out all reference fields: see bug 4006245 */
        target = null;
        //线程退出时,才断开ThreadLocalMap引用
        threadLocals = null;
        inheritableThreadLocals = null;
        inheritedAccessControlContext = null;
        blocker = null;
        uncaughtExceptionHandler = null;
    }

3、源码分析

本次源码分析,主要分析ThreadLocal的set,get,remove三个方法,分别以此为入口,一步步深入每个代码方法查看其实现原理,在这分析之前,先捡几个我理解比较重要的方法或者代码片段先解释一下,有一个初步的理解,后面会更顺畅。

3.1、重要代码片段

//一、ThreadLocalMap的寻址,因其底层是数组,在存放元素如何定位索引i存储? 
   //两个要求:1)求的索引位置一定要在数组大小内
     //       2)索引足够均分分散,要求hashcode足够散列,目的减少hash冲突。
            //firstKey.threadLocalHashCode,就是为了达到要求2,均分分散
            // &(INITIAL_CAPACITY - 1) 为了落在数组范围内,常用进行模运算,这里是巧妙运用位运算,效率更高, %2^n与 &(2^n-1)等价,所以要求数组的容量要为2的幂;
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);


// -------------------> firstKey.threadLocalHashCode,
//传入的ThreadLocal对象,做了 0x61c88647的增量后求得hash值,为什么要加0x61c88647呢,与斐波那契数列有关,反正是一个神奇的魔法值,目的就是使的hash值更分散,减少hash冲突。
 private final int threadLocalHashCode = nextHashCode();
 private static final int HASH_INCREMENT = 0x61c88647;
 private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }


//二、如何ThreadLocalMap中,出现hash冲突了,即2个ThreadLocal对象的hash计算出来是相同的下标,这里解决hash冲突使用线性探测法,即这个位置冲突,就寻找下一个位置,如果到数组终点了呢,从0再开始,所以这里数组逻辑上是一个首尾相接的环形数组。

//1,向后遍历,获取索引位置
private static int nextIndex(int i, int len) {
     return ((i + 1 < len) ? i + 1 : 0);
}
//2,向前遍历
private static int prevIndex(int i, int len) {
      return ((i - 1 >= 0) ? i - 1 : len - 1);
}
如下图:

多线程2一ThreadLocal源代码分析_第6张图片

3.2、重要方法分析

cleanSomeSlots 原理图1如下:

多线程2一ThreadLocal源代码分析_第7张图片

//一,分析清理失效Entry方法,清理起始位置是staleSlot
//已经知道某个Entry的key==null了,那么数组该位置的引用应该被清除 
   private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

         //Entry的value引用也清除,方便gc回收  
            tab[staleSlot].value = null;
         // 清理数组当前位置的Entry
            tab[staleSlot] = null;
            size--;

            // Rehash until we encounter null
            Entry e;
            int i;
           //向后循环遍历,直到遇到 null
           //做2件事:
               //1)遇到其他失效Entry,顺手清除
               //2)没有失效的Entry,重新hash一下,安排新位置;因为可能之前某些位置有hash冲突,导致根据key生成hash的值与当前的位置i不一致(冲突,会往后顺延,这里是逻辑上往后,达到数组长度,从0开始),而这时又清理了不少失效的Entry,可能会有空位了,所以重新hash调一下顺序,提高效率。
            for (i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();
                if (k == null) {
                  //1,失效Entry,清除
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                   //2,hash值与当前数组索引位置不同
                    if (h != i) {
                        tab[i] = null;
                       //3,向后遍历,找合适空位置插入
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
          //返回i位置, Entry ==null
            return i;
        }


//二、可伸缩性遍历某段范围失效的Entry cleanSomeSlots(int i, int n),原理如上图1
//为什么要有伸缩性,我理解还是为了效率,如果发现这范围内有需要清理的失效Entry,才把范围放大一些查找清除,源代码如下:

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];
               // 遇见有失效的Entry,当n传入的是size,即数组实际容纳的数量,n扩大到数组长度了,
              //影响在于,原来清理遍历的只是数组的一个小范围,一下子扩大到了整个数组。我理解这样做为了提高执行效率,没有检测到失效entry就小范围清理一下,检测到就大范围清理。
                if (e != null && e.get() == null) {
                    n = len;
                    removed = true;
                    i = expungeStaleEntry(i);
                }
            // n >>>= 1,即 n向右位移1位,即 n/2, 可循环次数log2n次
            } while ( (n >>>= 1) != 0);
            return removed;
        }

//三、当在set时,发现当前生成的数组位置已经被其他Entry占了,但是它失效了,key==null,这时需要把它给替换了吧,replaceStaleEntry(ThreadLocal key, Object value,int staleSlot),较难理解,多看几遍哈,原理图看下面,分析了2种情况,还有前后遍历都发现有失效的Entry情况,请自行脑补了哈。

//源代码如下:

private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;
            Entry e;
            // 1,要清除的位置
            int slotToExpunge = staleSlot;
           //2,从i 向前遍历,找到左边第一个失效的位置(指的是Entry !=null,key==null)
            for (int i = prevIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = prevIndex(i, len))
                if (e.get() == null)
                    slotToExpunge = i;
            //3,从i向后遍历
            for (int i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();
              
                //4,传入 staleSlot的 key==null,是一个失效的Entry, 从staleSlot+1个向后遍历,如果
              //遇见 k==key,将staleSlot索引位置与此处i替换位置,即将失效的Entry往后面放
                if (k == key) {
                    e.value = value;

                    tab[i] = tab[staleSlot];
                    tab[staleSlot] = e;

                    // Start expunge at preceding stale entry if it exists
                    //如果相等,staleSlot左边没有失效的entry,赋值为此处i,此处已经替换为失效Entry了,如果不相等,那么就清除失效Entry,以staleSlot最左边那一个失效entry开始清除
                    if (slotToExpunge == staleSlot)
                        slotToExpunge = i;
                    cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                   //cleanSomeSlots的目的:expungeStaleEntry返回的是entry ==null的索引i,
                  //清理i到len这一段的失效entry,中间会有null的情况吗?
                    return;
                }
               //5,slotToExpunge == staleSlot 表示 左边没有失效entry, 右边遇见第一失效entry,标记此处索引,以便后文确定从哪里开始清除无效entry
                if (k == null && slotToExpunge == staleSlot)
                    slotToExpunge = i;
            }

            //解除value的引用,gc会回收
            tab[staleSlot].value = null;
            //数组失效Entry位置,赋值新的Entry
            tab[staleSlot] = new Entry(key, value);

           //6,不相等,肯定有失效索引需要清理,执行清除
            if (slotToExpunge != staleSlot)
                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
        }

replaceStaleEntry 情景图1如下:

多线程2一ThreadLocal源代码分析_第8张图片

replaceStaleEntry 情景图2如下:

多线程2一ThreadLocal源代码分析_第9张图片

3.3、set(T): void

set 方法,是代码最多的,也是最重要的。其中expungeStaleEntry, replaceStaleEntry,cleanSomeSlots 三个方法较为主要,目的是找出、清理失效的Entry的过程,其中replaceStaleEntry 较难理解。

//一、从 set() 着手,入口

public void set(T value) {
        //1,获取当前线程对象
        Thread t = Thread.currentThread();
        //2,获取当前线程的map, 每个线程持有一个threadLocals对象,通过该map来实现线程之间数据的隔离,达到每个线程拥有自己独立的局部变量。 见代码分析二
        ThreadLocalMap map = getMap(t);
        if (map != null)
           // 见代码分析四
            map.set(this, value);
        else 
          //3,如果当前线程持有的map为空,创建map,见代码分析三 
            createMap(t, value);
    }
 

//二、 获取ThreadLocalMap 方法,获取当前线程持有的map对象 
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

 // Thread类中持有hreadLocalMap类型的对象,该map是ThreadLocal的静态内部类
    ThreadLocal.ThreadLocalMap threadLocals = null;


//三、代码分析 
   void createMap(Thread t, T firstValue) {
       // 创建 map对象,下见ThreadLocalMap的构造方法,很关键,该map与常用的HashMap等不同
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
   
   //构造方法,ThreadLocalMap 能够实现key-value的map集合结构,底层实际是一个数组,Entry为其每个节点对象,Entry 包含key和value
   ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
           //1,初始化容量为16的Entry[]数组 
            table = new Entry[INITIAL_CAPACITY];
           //2,这一步目的就是根据传入的ThreadLocal对象作为key,为了求放在数组下的索引位置,确定放在哪
           //两个要求:1)求的索引位置一定要在数组大小内(这里即0-15范围)
             //      2)索引足够均分分散,要求hashcode足够散列,目的减少hash冲突。
            //firstKey.threadLocalHashCode,就是为了达到要求2
            // &(INITIAL_CAPACITY - 1) 为了落在数组范围内,常用进行模运算,这里是巧妙运用位运算,效率更高, %2^n与 &(2^n-1)等价
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
           //求得索引位置,放入数组中
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
           //设置数组容量阈值,即填充因子,用于后续判断是否需要扩容
            setThreshold(INITIAL_CAPACITY);
        }



 //为了使传入的ThreadLocal对象求在数组索引位置,求的其hashcode,加上了0x61c88647增量,目的是为了足够分散
  private static final int HASH_INCREMENT = 0x61c88647;
    /**
     * Returns the next hash code.
     */
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

     
  //设置数组扩容阈值
        private void setThreshold(int len) {
           //初始填充因子为2/3,数组容量的2/3,即 16*2/3=10
            threshold = len * 2 / 3;
        }


//四、代码分析 set(key,value)
     private void set(ThreadLocal<?> key, Object value) {
       
            Entry[] tab = table;
            int len = tab.length;
            //求数组索引位置
            int i = key.threadLocalHashCode & (len-1);
            //这里用for循环,是为了解决hash冲突时,查找下一个可用 slot(卡槽,位置; 即生成的索引i,发现已有Entry占用了,找下一个位置插入,这里解决hash冲突方式不同于hashmap的拉链法(在冲突位置,以链表形式串接),这里采用的是线性寻址法,即数组当前i位置被占用了,看第i+1个位置,如果i+1已经大于等于数组length,再从数组下标0 从头开始,从该i = nextIndex(i, len)可知道是逻辑上这是一个首尾循环式数组)
       
            for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
      //1,从i向后遍历,若Entry为null,跳出循环; 不为null,获取Entry的key,线程初始化 threadLocalMap集合就有3个 Entry(此处不解?debug看了)
                ThreadLocal<?> k = e.get();
                //2,如果数组当前位置key与将要设值的 threadlocal对象相等,覆盖原value,返回 
                if (k == key) {
                    e.value = value;
                    return;
                }
            
                if (k == null) {
          //3,如果数组当前位置key为空,需要替换失效的Entry(stale:不新鲜的,Entry的key ==null)
                //见代码分析五 
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
            //4,如果上面for循环,出现hash冲突了,跳出循环,此时索引i位置 Entry==null,在此插入新Entry
            tab[i] = new Entry(key, value);
            int sz = ++size;
           //5,cleanSomeSlots,顺便清理一下失效的Entry,避免内存泄漏,见代码分析六
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
               // 6,清理失败且当前数组的Entry数量达到设定阈值了,执行 rehash,见代码分析八
                rehash();
        }

//五、 分析 replaceStaleEntry(key, value, i) 替换失效的Entry

  private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;
            Entry e;
            // 1,要清除的位置
            int slotToExpunge = staleSlot;
           //2,从i 向前遍历,找到左边第一个失效的位置(指的是Entry !=null,key==null)
            for (int i = prevIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = prevIndex(i, len))
                if (e.get() == null)
                    slotToExpunge = i;
            //3,从i向后遍历
            for (int i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();
              
                //4,传入 staleSlot的 key==null,是一个失效的Entry, 从staleSlot+1个向后遍历,如果
              //遇见 k==key,将staleSlot索引位置与此处i替换位置,即将失效的Entry往后面放,
                if (k == key) {
                    e.value = value;

                    tab[i] = tab[staleSlot];
                    tab[staleSlot] = e;

                    // Start expunge at preceding stale entry if it exists
                    //如果相等,staleSlot左边没有失效的entry,赋值为此处i,此处已经替换为失效Entry了,如果不相等,那么就清除失效Entry,以staleSlot最左边那一个失效entry开始清除
                    if (slotToExpunge == staleSlot)
                        slotToExpunge = i;
                    cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                   //cleanSomeSlots的目的:expungeStaleEntry返回的是entry ==null的索引i,
                  //清理i到len这一段的失效entry,中间会有null的情况吗?
                    return;
                }
               //5,slotToExpunge == staleSlot 表示 左边没有失效entry, 右边遇见第一失效entry,标记此处索引,以便后文确定从哪里开始清除无效entry
                if (k == null && slotToExpunge == staleSlot)
                    slotToExpunge = i;
            }

            //解除value的引用,gc会回收
            tab[staleSlot].value = null;
            //数组失效Entry位置,赋值新的Entry
            tab[staleSlot] = new Entry(key, value);

           //6,不相等,肯定有失效索引需要清理,执行清除
            if (slotToExpunge != staleSlot)
                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
        }


//六、分析 cleanSomeSlots(int i, int n),清理某些失效的Entry方法
//i为 失效位置, n分2种传入场景  
// 1)数组的实际Entry数量 size 
// 2) 数组的容量 length
 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];
               // 遇见有失效的Entry,当n传入的是size,即数组实际容纳的数量,n扩大到数组长度了,
              //影响在于,原来清理遍历的只是数组的一个小范围,一下子扩大到了整个数组。我理解这样做为了提高执行效率,没有检测到失效entry就小范围清理一下,检测到就大范围清理。
                if (e != null && e.get() == null) {
                    n = len;
                    removed = true;
                    i = expungeStaleEntry(i);
                }
            // n >>>= 1,即 n向右位移1位,即 n/2, 可循环次数log2n次
            } while ( (n >>>= 1) != 0);
            return removed;
        }



//七、分析清理失效Entry方法,清理起始位置是staleSlot
   private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

            // 清理当前位置的Entry
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;

            // Rehash until we encounter null
            Entry e;
            int i;
           //向后循环遍历,直到遇到 null
           //做2件事:
               //1)遇到其他失效Entry,顺手清除
               //2)没有失效的Entry,重新hash一下,安排新位置;因为可能之前某些位置有hash冲突,导致根据key生成hash的值与当前的位置i不一致(冲突,会往后顺延,这里是逻辑上往后,达到数组长度,从0开始),而这时又清理了不少失效的Entry,可能会有空位了,所以重新hash调一下顺序,提高效率。
            for (i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();
                if (k == null) {
                  //1,失效Entry,清除
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                   //2,hash值与当前数组索引位置不同
                    if (h != i) {
                        tab[i] = null;
                       //3,向后遍历,找合适空位置插入
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
          //返回i位置, Entry ==null
            return i;
        }

//八、rehash
   //首先扫描全表,清除所有失效的Entry, 如果这还不能充分地缩小数组的大小,扩容为当前的2倍
        private void rehash() {
           //1,清除所有失效的entry,见代码分析九
            expungeStaleEntries();

            //2,threshold = length * 2/ 3
            //size >= threshold - threshold / 4 = threshold*3/4 ,
            //即size >= length *2/3 *3/4= length* 1/2, 只要数组的大小>=于数组容量的一半,就扩容。
            if (size >= threshold - threshold / 4)
               //见代码分析十
                resize();
        }


//九、遍历数组全部节点,清除失效的Entry
 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);
            }
        }

//十、扩容为原来的2倍
  private void resize() {
            Entry[] oldTab = table;
            int oldLen = oldTab.length;
            int newLen = oldLen * 2;
            Entry[] newTab = new Entry[newLen];
            int count = 0;
          // 旧数组数据向新数组迁移,顺便清除失效的entry的value,帮助Gc容易发现它,直接回收
          //Entry不清除了吗?这里旧数组之后就没有被人引用了,下次Gc会直接回收
            for (int j = 0; j < oldLen; ++j) {
                Entry e = oldTab[j];
                if (e != null) {
                    ThreadLocal<?> k = e.get();
                    if (k == null) {
                        e.value = null; // Help the GC
                    } 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;
    
  }

3.4、get():T

//一、从get() 着手
   public T get() {
       //1,获取当前线程对象
        Thread t = Thread.currentThread();
       //2,获取该线程的 map集合,每个线程都有单独的map
        ThreadLocalMap map = getMap(t);
        if (map != null) {
           //3,this指的是 ThreadLocal对象,以它为key,去map中获取相应的Entry,
          //易混淆:ThreadLocalMap 中存储的Entry键值对,key是ThreadLocal对象,而不是线程对象。
          //此处 map.getEntry(this) 下面代码二 分析
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
               //4,返回value
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
       //该线程若没有map对象, 返回初始默认值,详见代码分析四
        return setInitialValue();
    }


// 二、分析 map.getEntry(this)

  private Entry getEntry(ThreadLocal<?> key) {
            //1,获取数组索引位置
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
             //2,直接就命中,没有hash冲突,返回
                return e;
            else
              //3,遍历其他Entry,见代码分析三
                return getEntryAfterMiss(key, i, e);
        }


//三、根据key获取Entry,没有直接命中,继续遍历查找

 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) 
                 //1,命中返回,为啥重复判断一次? 因为这是在while循环,会往后执行再判断
                    return e;
                if (k == null)
                  //2,当前位置Entry失效,清除
                    expungeStaleEntry(i);
                else
                  //3,hash冲突,获取下一个索引
                    i = nextIndex(i, len);
                e = tab[i];
            }
          //4,数组中没有找到该key
            return null;
        }

//四、没有map,返回默认值,初始化操作

    private T setInitialValue() {
       //1,调用默认的初始化方法, 如下,一般用来被重写的,给定一个初始值
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

  protected T initialValue() {
        return null;
    }

3.5、remove():void

// 一、入口  
public void remove() {
        //1,获取当前线程的map集合 
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
           //2,见代码分析二
             m.remove(this);
     }


// 二、 m.remove(this);
   private void remove(ThreadLocal<?> key) {
            Entry[] tab = table;
            int len = tab.length;
            //1、获取该key在数组中索引位置 
            int i = key.threadLocalHashCode & (len-1);
           //2,从i位置向后循环判断,考虑hash冲突
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                //3,找到该key,
                if (e.get() == key) {
                   //4,引用置空 
                    e.clear();
                   // 5,从i开始清除失效的Entry,避免内存泄漏
                    expungeStaleEntry(i);
                    return;
                }
            }
  }

//引用置空
 public void clear() {
        this.referent = null;
    }

3.6、总结

从set,get,remove代码可见,每个方法都会去清除失效的Entry,说明设计者也考虑到内存泄漏的问题,所以建议在使用完ThreadLocal,及时执行remove方法清除一下,避免潜在的内存泄漏问题。

道阻且长,且歌且行!
每天一小步,踏踏实实走好脚下的路,文章为自己学习总结,不复制黏贴,就是想让自己的知识沉淀一下,也希望与更多的人交流,如有错误,请批评指正!

你可能感兴趣的:(Java多线程之美)