首页 / JAVA / java ThreadLocal解析

java ThreadLocal解析

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了java ThreadLocal解析，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8020字，纯文字阅读大概需要12分钟。

内容图文

ThreadLocal内部设计

在java8中ThreadLocal是这样设计的:每个Thread维护一个threadLocalMap,这个Map的key是ThreadLocal本身,value才是真正要存储的Object

具体过程是这样的

  1. 每个Thread线程内部都有一个Map(ThreadLocalMap)
  2. Map里面存储ThreadLocal对象(key)和线程的变量副本
  3. Thread内部的Map是由ThreadLocal维护的,由ThreadLocal负责向Map获取和设置线程的变量值
  4. 对于不同的线程每次获取副本值时,别的线程并不能获取到当前线程的副本值,形成了副本值的隔离

java ThreadLocal解析 - 文章图片

 

 

 jdk8中这样设计有两个好处,

  1. 往往在开发当中ThreadLocal的数量是少于线程数量的,所有每个Map存储的Entry数量变少
  2. 当Thread销毁的时候,ThreadLocal也会随之销毁,减少内存开销

 

ThreadLocal源码分析

 /**
     * 设置当前线程对应的ThreadLocal的值
     * @param value
     */
    public void set(T value) {
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取此线程对象中维护的ThreadLocalMap对象
        ThreadLocal.ThreadLocalMap map = getMap(t);
        // 判断map是否存在
        if (map != null)
            // 存在则设置此实体entry
            map.set(this, value);
        else
            // 1 当前线程Thread 不存在ThreaLocal对象
            // 2 则调用createMap进行ThreadLocalMap对象的初始化
            // 3 并将 t(当前线程)和value作为第一个entry存放至ThreadLocalMap中
            createMap(t, value);
    }

    /**
     * 返回当前线程中保存的ThreadLocal的值
     * 如果当前线程没有此ThreadLocal变量,则他会通过调用 setInitialValue 方法进行初始化,
     *
     * @return 如果存在则返回值,如果不存则创建并返回初始值null
     */
    public T get() {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // 获取此线程对象中的ThreadLocalMap对象
        ThreadLocal.ThreadLocalMap map = getMap(t);
        if (map != null) {
            // 以当前的threadLocal为key,调取getEntry获取对应的存储实体e
            ThreadLocal.ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        // 初始化 有两种情况执行当前代码
        // 1 map不存在,标识此线程没有维护的ThreadLocalMap对象
        // 2 map存在,但是没有与当前ThreadLocal关联的entry
        return setInitialValue();
    }

    /**
     * 删除当前线程中保存的ThreadLocal对应的实体Entery
     */
    public void remove() {
        // 获取当前线程对象中维护的ThreadLocalMap对象
        ThreadLocal.ThreadLocalMap m = getMap(Thread.currentThread());
        // 如果此map存在
        if (m != null)
            // 则调用map.remove
            // 以当前ThreadLocal为key删除对应的实体entry
            m.remove(this);
    }

ThreadLocalMap源码分析

ThreadLocalMap是ThreadLocal的内部类,没有实现Map接口,用独立的方式实现了Map的功能,其内部的Entry也是独立实现

java ThreadLocal解析 - 文章图片

 

 

 

 成员变量

 

  /**
     * 初始容量 -- 必须是2的整次幂
     */
    private static final int INITIAL_CAPACITY = 16;

    /**
     * 存放数据的table,
     * 通用数组长必须是2的整次幂
     */
    private Entry[] table;

    /**
     * 数组里entrys的个数,可以用于判断table当前使用量是否超过阈值
     */
    private int size = 0;

    /**
     * 进行扩容的阈值,表使用量大于它的时候进行扩容
     */
    private int threshold; // Default to 0

存储结构 Entry

/**
     * Entry继承weakReference,并且用ThreadLocal作为key
     * 如果key为null(entry.get()==null),意味着key不在被引用,因此这时候entry也可以从table中清除
     */
    static class Entry extends WeakReference<ThreadLocal<?>> {
        /** The value associated with this ThreadLocal. */
        Object value;

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

在ThreadLocalMap中,也是用Entry来保存K-V数据结构的,不过entry中的key只能是threadLocal对象,这点在构造方法中已经限定死了,另外Entry继承weakReference,也就是key(ThreadLocal)是弱引用,其目的是将ThreadLocal对象的声明周期和线程声明周期解绑

 

弱引用和内存泄漏


强引用: 就是我们最常见的普通对象引用,只要还有强引用指向一个对象,就能带边对象还活着,垃圾回收器就不会回收这种对象

弱引用: 垃圾回收器一旦发现了只具有弱引用的对象,不管当前内存空间是否足够,都会回收它的内存,但是弱引用的对象,被其他强引用对象所引用,依然不会被回收

1在业务代码中,使用完threadLocal,threadLocal 的引用被回收

2 由于ThreadLocalMap只持有ThreadLocal的弱引用,没有任何强引用执行啊threadlocal实例,所以threadlocal就可以被gc回收,此时entry中的key=null

3 但是在没有手动删除这个entry,以及currentThread依然在运行的前提下(线程池场景),也存在有强引用链 threadRef -> currentThread -> threadLocalMap -> entry -> value ,value不会被回收,而这块value永远不会被访问到了,导致value内存泄漏

也就是说threadLocalMap中的key使用了弱引用,也有可能内存泄漏

 java ThreadLocal解析 - 文章图片

 

 entry为什么使用弱引用?

ThreadLocalMap中的set/getEntry方法中,会对entrys中所有key(也就是ThreadLocal为null)进行判断,如果为null的话,那么就会对value置为null,这就意味着,使用完ThreadLocal,currentThread依然运行的前提下,就算忘记调用remove方法,弱引用比强引用可以多一层保障:弱引用的ThreadLocal会被回收,对应的value在下一次ThreadLocalMap调用set get remove中的任一方法的时候会被清除,从而避免内存泄漏

 

hash冲突的解决

ThreadLocalMap的构造方法

   /**
     * 
     * @param firstKey 本ThreadLocal实例
     * @param firstValue 要保存的线程本地变量
     */
    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        // 初始化table
        table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY];
        // 计算索引(重点代码)
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        // 设置值
        table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
        size = 1;
        // 设置阈值
        setThreshold(INITIAL_CAPACITY);
    }

构造一个长度为16的entry数组,然后计算出firstKey对应的索引,然后存储到table中,并设置size和threshold

重点分析    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);

关于 firstKey.threadLocalHashCode  :

 private final int threadLocalHashCode = nextHashCode();
    // 原子Integer类,用于并发场景下做加减操作,保障线程的安全
    private static AtomicInteger nextHashCode = new AtomicInteger();
    // 特殊的hash值
    private static final int HASH_INCREMENT = 0x61c88647;

    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

这里定义了一个 AtomicInteger  类型,每次获取当前值并加上 HASH_INCREMENT , HASH_INCREMENT 的值跟斐波那契数列(黄金分割数列)有关,其主要目的是为了让hash值能够更均匀的分布在2的n次方的数组里,也就是entry[] table中,这样做可以避免hash冲突

关于 & (INITIAL_CAPACITY - 1): 

计算hash的时候采用hashCode&(size -1) 的算法,这相当于取模运算hashCode % (size-1) 的一个更高效的实现,正因为这种算法,我们要求size必须是2的整次幂,这也能保证在索引不越界的前提下,是的hash发生的冲突次数减小

 ThreadLocalMap中的set方法

 private void set(ThreadLocal<?> key, Object value) {
        ThreadLocal.Entry[] tab = table;
        int len = tab.length;
        // 计算索引
        int i = key.threadLocalHashCode & (len-1);
        /**
         * 使用线性探测发查找元素(重点代码)
         */
        for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
             e != null;
             e = tab[i = nextIndex(i, len)]) {
            ThreadLocal<?> k = e.get();
            // ThreadLocal 对应的 key 存在,直接覆盖之前的值
            if (k == key) {
                e.value = value;
                return;
            }
            // key为null,但是值不为null,说明之前的ThreadLocal对象已经被回收了
            // 当前数组中的Entry是一个陈旧的元素
            if (k == null) {
                // 用新的元素替换陈旧的元素,这个方法进行了不少垃圾清理动作,防止内存泄漏
                replaceStaleEntry(key, value, i);
                return;
            }
        }
        // ThreadLocal对应的key不存在并且没有找到陈旧的元素,则在空元素的位置创建一个新的Entry
        tab[i] = new ThreadLocal.ThreadLocalMap.Entry(key, value);
        int sz = ++size;
        /**
         * cleanSomeSlots 用于清除那些 e.get==null(没有引用了,说明可以被回收) 的元素
         * 这种数据的key关联的对象已经被回收,所以这个entry可以被置为null
         * 如果没有清除任何entry,并且使用量到达了负责因子所定义的长度,那么进行
         * rehash 这个方法首先会回收一次 entrys,如果回收完之后满足 size(当前数量) >= threshold(阈值) - threshold(阈值) / 4 ,
         * 则进行扩容,扩容为当前容量的2倍 16 *2
         */
        if (!cleanSomeSlots(i, sz) && sz >= threshold)
            rehash();
    }

    
    // 获取环形数组的下一个索引
    private static int nextIndex(int i, int len) {
        return ((i + 1 < len) ? i + 1 : 0);
    }

代码执行流程:

1 首先根据key计算出索引i,然后查找i位置上的entry

2 若entry存在并且key等于传入的key,那么这个时候直接给这个entry赋新的value值

3 若entry存在并且key为null,则调用replaceStaleEntry来更换这个key为空的Entry

4 不断循环检测,知道遇到为null的地方,这个时候如果还没有在循环中return,那么就在null的位置新建一个entry,并且插入,同事size增加1

最后调用cleanSomeSlots,清理key为null的Entry,最后返回是否清理了Entry,接下来再判断sz是否达到rehash的条件,达到的话就进行一次rehash函数,执行一次全表扫描清理,如果清理完之后,需要扩容,则进行扩容

ThreadLocalMap使用线性探测法来解决hash冲突:

该方法一次探测下一个地址,直到有空的地址后插入,若整个空间都找不到空余的地址,则产生溢出.

举个例子,假设当前的table长度为16,也就是说如果计算出来的key的hash值为14,如果table[14]上已经有值,并且其key与当前key不一致,那么就发生hash冲突,这个时候将14加1得到15,去table[15]进行判断,这个时候如果还是冲突,会回到索引0,去table[0],以此类推

按照上面的描述,可以把Entry[] table看成一个环形数组

 

内容总结

以上是互联网集市为您收集整理的java ThreadLocal解析全部内容，希望文章能够帮你解决java ThreadLocal解析所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/622483.html

来源：【匿名】