ThreadLocal 工作原理部分源码分析

Posted Fri_yu

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了ThreadLocal 工作原理部分源码分析相关的知识,希望对你有一定的参考价值。

1.大概去哪里看

ThreadLocal 其根本实现方法,是在Thread里面,有一个ThreadLocal.ThreadLocalMap属性

ThreadLocal.ThreadLocalMap threadLocals = null;


ThreadLocalMap 静态内部类维护了一个Entry 数组

private Entry[] table;

查看Entry 源码,它维护了两个属性,ThreadLocal 对象 与一个Object

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

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

那么,这几项似乎可以这么串下来: Thread. currentThread().threadLocals. table{当前线程,的ThreadLocalMap对象,的Entry数组}(忽略访问权限的事儿)

------------------------------------------------我是分割线------------------------------------------------

2.代码实现分析

ThreadLocal 提供set(),get()方法,用于数据的写入与读取。数据的存储与获取的位置,即
Thread. currentThread().threadLocals. table {当前线程,的ThreadLocalMap对象,的Entry数组}

public void set(T value) {
        Thread t = Thread.currentThread();//获取当前线程t
        ThreadLocalMap map = getMap(t);//获取threadLocals 对象
        if (map != null) 
            map.set(this, value);//调用 ThreadLocalMap 的set方法向 threadLocals 中写入一条数据
        else
            createMap(t, value);//如果threadLocals 为null 则为当前线程t 创建一个map,并插入数据
}

map.set(this, value);注意,这里,传入的第一个参数为this 即 ThreadLocal 对象自身,

假如我们声明了一串代码:

private static ThreadLocal<String> threadLocal = new ThreadLocal<String>();

然后我们又执行了 threadLocal.set(“string 1234”);
那么,在Thread. currentThread().threadLocals. table 中,应该有这么一个Entry :ThreadLocal指向threadLocal,value 为 “string 1234”

分析源码(这里,所有的源码都来自于jdk1.7.0_71):

private void set(ThreadLocal<?> key, Object value) {

            // We don‘t use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);

            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                if (k == key) {
                    e.value = value;
                    return;
                }

                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

分析两处:
1. int i = key.threadLocalHashCode & (len-1);
根据当前的ThreadLocal 的threadLocalHashCode 跟 ThreadLocalMap.table的长度-1 ,按位与,获得目标索引值 i , 如果tab[i] 为空的话,将会在 tab[i] 处插入一个Entry ;

2. for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)])

如果如果tab[i] 不为空,则调用i = nextIndex(i, len) 将i值进行+1或者置为0,然后判断e是否为null 如果e!=null 判断e 中的 ThreadLocal对象,跟传入的ThreadLocal 对象,是否为同一个对象。如果是同一个对象,则对e的value 进行重新赋值。如果在遍历的过程中发现某个e的ThreadLocal 对象为空,则将Entry(threadLocal,” string 1234”) 设置在此时的tab[i]处。
(如果一开始进来的时候e 为null 即 tab[i]==null 。是不会走for循环的,会直接把Entry(threadLocal,” string 1234”) 赋值到table[i]);

private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}

分析,为什么会有i = nextIndex(i, len) 这样的设定
执行int i = key.threadLocalHashCode & (len-1);的时候,很可能不同的key.threadLocalHashCode得到了相同的 i 值,那么,就从 i 开始,遍历table对象,找到一个可以放置Entry(threadLocal,” string 1234”) 的位置,

比如:

    System.out.println(626627285 & 16-1);//5
    System.out.println(626627317 & 16-1);//5
    System.out.println(626627573 & 16-1);//5

这三个,获取到的i值,都为5(当然实际用到的hashCode的算法不是这样的,不会产生这么接近的数)。

在同一个线程中,626627285先set(value1)了,得到5,table[5]为空,那就填进去 table[5]=new Entry(626627285,value1);
626627317接着set(value2),算出来i=5,
但是table[5]已经有人占了,那就只能看table[6]有没有空闲位置,一看table[6]==null,好,就放这儿了table[6]=new Entry(626627317,value2);
626627573接着set(value3),算出来i=5,
但是table[5]已经有人占了,那就只能看table[6]有没有空闲位置,一看table[6]也被占了,再看table[7]==null,好,就放这儿了table[7]=new Entry(626627573,value3)
假如有个线程算出来i=15 但是table[15]!=null,需要向后找空闲位置,table[16]是越界的,nextIndex返回0,从table[0]开始找

下面这串代码,维护了table 的长度,避免了遍历了一圈table 却找不到 table[i]==null 的情况,即保证table的某些索引处肯定为null,因为还没填满的时候就已经扩容了。

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

 

------------------------------------------------我是分割线------------------------------------------------

下面分析get()

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
}

1. 获取当前线程的threadLocals 并传入 ThreadLocal 对象,获取对应的值。
2. 如果当前线程的threadLocals 为null ,则为当前线程t 创建一个map,并插入数据setInitialValue ()=null,并返回null

private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

分析map.getEntry(this)

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);
}

这里看到,也是先使用 int i = key.threadLocalHashCode & (table.length - 1); 得到一个索引值,然后去table获取 Entry对象,得到几种结果:
1. e!=null && e.get()!=key 因为是通过“int i = key.threadLocalHashCode & (table.length - 1);”获取的索引值,不同的ThreadLocal 对象,可能获取到相同的索引值,所以,这种情况是存在的。
2. e==null 当前的ThreadLocal 对象 压根儿没有set值。
3. e!=null&&e.get()==key 如果Entry对象的key值与当前传入的ThreadLocal 对象,是同一个对象,则返回e 然后在 get()方法中,返回e.value;
以上 1、2 两种情况的时候,会执行getEntryAfterMiss(key, i, e);

在同一个线程中,626627285、626627317、626627573算到的i值均为5,但是只有626627285==table[5].get(),
626627317、626627573这两个,都需要走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;
}

1. 如果初始出入的e==null 则不进入while 循环直接返回null

2. 在while循环里面,如果e.get()==key 即,e 的Entry对象的key值与当前传入的ThreadLocal 对象,是同一个对象,则返回e 。
3. 如果e.get()==null 的情况下,先将table[i]置为空,然后向后遍历直到
table[nextIndex(i, len)]==null,将table[nextIndex(i, len)]!=null的对象,重新写入table中。
4. k!=key&&key!=null的时候,则调用i = nextIndex(i, len) 将i值进行+1或者置为0,然后判断e是否为null 如果e!=null 判断e 中的 ThreadLocal对象,跟传入的ThreadLocal 对象,是否为同一个对象。如果是同一个对象,返回当前的 Entry对象,如果遇到了e==null的时候,还没有找到目标的Entry ,就返回null 。
为什么找到e==null的地方就可以跳出了呢?
如果如果tab[i] 不为空,则调用i = nextIndex(i, len) 将i值进行+1或者置为0,然后判断e是否为null 如果e!=null 判断e 中的 ThreadLocal对象,跟传入的ThreadLocal 对象,是否为同一个对象。如果是同一个对象,则对e的value 进行重新赋值。如果在遍历的过程中发现某个e的ThreadLocal 对象为空,则将Entry(threadLocal,” string 1234”) 设置在此时的tab[i]处。
这里,插入的Entry(threadLocal,” string 1234”) ,要么,在初始的i 处,要么,往后+1顺延,不会跳过某个索引值,然后进行赋值。所以,当table[i]==null的时候,已经可以不继续找了。


------------------------------------------------我是分割线------------------------------------------------

3 还有一点我觉得很重要的东西

分析到这里的时候,我们应该有发现一个很重要的问题,即:
int i = key.threadLocalHashCode & (table.length - 1);
获得的i值是固定的吗?
很明显不是的,因为table 会扩容,table.length 会变,得到的i值也是不一样的:

System.out.println(626627285 & 16-1);//5
System.out.println(626627285 & 32-1);//21

这样的话,table[i]岂不是会出错?

然后,仔细阅读源码,在进行扩容的时候,会调用resize()方法:

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; // 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;
}

在resize() 方法中,我们看到,这里新建了一个长度为原本的长度2倍的Entry数组,然后,将原Entry数组的所有元素,

挨个儿的重新计算索引 int h = k.threadLocalHashCode & (newLen - 1);

然后赋值原有的Entry 到新的Entry 数组中,这样,就保证了数组扩容之后,获取到的 i 值,是适配新数组的正确的值。

继续拿626627285、626627317、626627573举例,这三个,在数组扩容为长度=32的时候,算出来的i值,均为21,那么他们将会是这么算的:
oldTab[5]!=null oldTab[5].get=626627285 算得i=21,table[21]==null table[21]=oldTab[5];
oldTab[6]!=null oldTab[6].get=626627317 算得i=21,table[21]!=null table[22]==null table[22]=oldTab[6];
oldTab[7]!=null oldTab[7].get=626627573 算得i=21,table[21]!=null tanle[22]!=null table[23]==null table[23]=oldTab[7];

 

------------------------------------------------我是分割线------------------------------------------------

 以上,是我个人查看jdk源码,分析出来的ThreadLocal得实现原理与工作原理。欢迎大家批评讨论斧正。谢谢

 

以上是关于ThreadLocal 工作原理部分源码分析的主要内容,如果未能解决你的问题,请参考以下文章

源码分析:InheriableThreadLocal传递数据的原理和ThreadLocal导致的内存泄露原因

多线程爬坑之路-ThreadLocal源码及原理的深入分析

史上最详细之ThreadLocal源码分析

源码分析--ThreadLocal(图解)

我惊了!!!ThreadLocal 源码存在内存泄露的 Bug!!!

我惊了!!!ThreadLocal 源码存在内存泄露的 Bug!!!