ThreadLocal

本文介绍了ThreadLocal的工作原理,包括ThreadLocalMap的结构和操作,强调ThreadLocal并非解决线程安全问题,而是提供线程隔离的变量。文章还深入探讨了ThreadLocal内存泄漏的原因,指出使用弱引用来防止内存泄漏的必要性,并给出避免内存泄漏的建议:使用完ThreadLocal后调用remove()方法。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1、简介

ThreadLocal提供了一种访问某个变量的特殊方式:访问到的变量属于当前线程,即保证每个线程的变量不一样,而同一个线程在任何地方拿到的变量都是一致的,这就是所谓的线程隔离

ThreadLocalMap并不是为了解决线程安全问题,而是提供了一种将实例绑定到当前线程的机制,类似于隔离的效果,实际上自己在方法中new出来变量也能达到类似的效果。ThreadLocalMap跟线程安全基本不搭边,绑定上去的实例也不是多线程公用的,而是每个线程new一份,这个实例肯定不是共用的,如果共用了,那就会引发线程安全问题。ThreadLocalMap最大的用处就是用来把实例变量共享成全局变量,在程序的任何方法中都可以访问到该实例变量而已。(摘自ThreadLocal使用

2、ThreadLocal的内部类ThreadLocalMap

(1)主要的结构

可以看到ThreadLocalMap使用Entry来实现key-value的结构,key就是ThreadLocal,value就是存储的值。Entry是一个弱引用。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。

static class ThreadLocalMap {

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

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

        private static final int INITIAL_CAPACITY = 16;//初始容量
        private Entry[] table;
        /**
         * The number of entries in the table.
         */
        private int size = 0;

        /**
         * The next size value at which to resize.
         */
        private int threshold; 

        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);//获取散列地址
            table[i] = new Entry(firstKey, firstValue);//设置key-value
            size = 1;//设置初始table中entry的长度
            setThreshold(INITIAL_CAPACITY);//设置阀值
        }


        /**
         * 根据parentMap创建ThreadLocalMap
         */
        private ThreadLocalMap(ThreadLocalMap parentMap) {
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            setThreshold(len);
            table = new Entry[len];

            for (int j = 0; j < len; j++) {
                Entry e = parentTable[j];
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
                    if (key != null) {
                        Object value = key.childValue(e.value);
                        Entry c = new Entry(key, value);
                        int h = key.threadLocalHashCode & (len - 1);
                        while (table[h] != null)//如果冲突了,使用链地址法寻找下一个地址
                            h = nextIndex(h, len);
                        table[h] = c;
                        size++;
                    }
                }
            }
        }
}

(2)主要方法

①链地址法寻找地址

        /**
         * Increment i modulo len.
         */
        private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }

        /**
         * Decrement i modulo len.
         */
        private static int prevIndex(int i, int len) {
            return ((i - 1 >= 0) ? i - 1 : len - 1);
        }

② 根据key返回对应的entry

步骤:

a.通过传入的key获取哈希地址i,从table取出该entry,如果entry的key与传入的key相同直接返回

b.否则通过getEntryAfterMiss继续寻找  {

b1.如果传入的entry e的key与要找的key相同,直接返回

b2.如果entry的key是null,删除陈旧entry

b3.链地址法寻找下一个哈希地址,更新 e=新entry

b4.如果b3更新的e!=null,重复步骤b1

}

       //返回以ThreadLocal作为key的Entry
       private Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode & (table.length - 1);//获取哈希地址
            Entry e = table[i];//取出table存放的entry
            if (e != null && e.get() == key)//如果entry不为空并且entry的key与寻找的key一致
                return e;//返回该entry
            else
                return getEntryAfterMiss(key, i, e);//没找到key情况下继续尝试寻找
        }

        /* @param  key the thread local object
         * @param  i the table index for key's hash code
         * @param  e the entry at table[i]
         */
        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)//如果entry的key和要寻找的key相同直接返回
                    return e;
                if (k == null)//如果entry的key是空的,删除过期的entry
                    expungeStaleEntry(i);
                else//否则继续寻找下一个地址
                    i = nextIndex(i, len);
                e = tab[i];//更新entry
            }
            return null;
        }

③删除旧的entry

步骤:

a.遍历table,如果entry为null或者entry的key为null,清除陈旧entry

   //删除table中所有陈旧的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)//如果entry不为null并且key为null
                    expungeStaleEntry(j);//删除指定数组下标的陈旧entry
       }
    }

 步骤:

a.将已经确定为陈旧的staleSolt位置的entry的key及entry置为null,table长度减1

b.从staleSolt往后继续寻找陈旧值(详细看下面代码)


  /* @param staleSlot index of slot known to have null key
   * @return the index of the next null slot after staleSlot
   */    
    private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;
            
            // expunge entry at staleSlot 
            tab[staleSlot].value = null;//1.1 entry的value置空
            tab[staleSlot] = null;//1.2 entry置空
            size--;//1.3 table的entry长度减一

            // Rehash until we encounter null
            Entry e;
            int i;
            for (i = nextIndex(staleSlot, len);//2.继续遍历寻找过期的值
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();
                if (k == null) {//2.1 key为空 (重复步骤1)
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {//2.2 key不为空,重新计算地址
                    int h = k.threadLocalHashCode & (len - 1);//获取哈希地址
                    if (h != i) {//如果不在同一个位置
                        tab[i] = null;//把老位置的entry置null(删除)

                        //从h开始往后遍历,一直到找到空为止,插入
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

下面slotToExpunge是最开始需要删除的陈旧的下标,通过往前遍历找到最开始的下标、往后遍历寻找是否可以更新这个下标(如果往前遍历找不到,slotToExpunge值就不会改变,那么根据key是否相同来更新slotToExpunge)。

举个例子,假设我从下面这个table中找key为1的,假设从2开始是staleslot,陈旧下标往前遍历更新了slotToExpunge=0,从后遍历的时候发现slotToExpunge!=staleslot,也就是说原来往前遍历找到了陈旧的entry,这说明不能再找到比它更前的陈旧下标了,所以后面操作都不会更新slotToExpunge了。

步骤:

a.如果找到与传入 key相等的entry,将其与陈旧entry交换,清除陈旧数据,并return

b.如果没找到对应key的entry,清空陈旧entry,并new一个entry放入陈旧位置

c.最后判断一下是否需要清除操作(具体看注释)

    //用新元素替换陈旧的元素   
     private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                                       int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;
            Entry e;

            int slotToExpunge = staleSlot;//需要删除的陈旧元素下标
            //1.从陈旧下标往前遍历
            for (int i = prevIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = prevIndex(i, len))
                if (e.get() == null)//如果key为空
                    slotToExpunge = i;//设置新的需要删除的开始索引
            
            //2.从陈旧下标往后遍历
            for (int i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();
                
                
                //2.1 如果找到对应的key, 需要将它与陈旧的entry交换来维持哈希表的顺序
                // 新的陈旧下标或者其他陈旧下标会通过expungeStaleEntry方法
                // 删除或者重新哈希所有的entry
                if (k == key) {//2.1.1如果该key值与要替换的key相同
                    e.value = value;//覆盖旧的value值

                    //交换
                    tab[i] = tab[staleSlot];
                    tab[staleSlot] = e;

                    // 从前面的陈旧entry开始删除
                    if (slotToExpunge == staleSlot)//2.1.2如果slotToExpunge等于传进来的staleSlot,说明在步骤1中没有找到陈旧的entry
                        slotToExpunge = i;//更新slotToExpunge 
                    cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);//2.1.2清除陈旧entry
                    return;
                }
                 
    
                //2.2 如果k是null并且在往后查询的步骤中没有找到过期的entry(也就是步骤2.1.2没有执行过),更新slotToExpunge 
                if (k == null && slotToExpunge == staleSlot)
                    slotToExpunge = i;
            }
            
            //2.3 如果没有找到对应的key,将新的entry放入陈旧的位置
            tab[staleSlot].value = null;
            tab[staleSlot] = new Entry(key, value);

            //2.4 If there are any other stale entries in run, expunge them
            if (slotToExpunge != staleSlot)
                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
        }

步骤:

从传入的位置i开始往后寻找清除陈旧entry

        private boolean cleanSomeSlots(int i, int n) {
            boolean removed = false;
            Entry[] tab = table;
            int len = tab.length;
            //往后遍历删除陈旧entry
            do {
                i = nextIndex(i, len);
                Entry e = tab[i];
                if (e != null && e.get() == null) {//如果entry不为null并且entry里面的key是null
                    n = len;
                    removed = true;
                    i = expungeStaleEntry(i);//清除陈旧entry
                }
            } while ( (n >>>= 1) != 0);
            return removed;
        }

④set操作

        /**
         * Set the value associated with key.
         *
         * @param key the thread local object
         * @param value the value to be set
         */
        private void set(ThreadLocal<?> key, Object value) {

            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);//获取元素放置的位置
            //从i位置开始往后遍历
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                if (k == key) {//如果key相等,覆盖原value
                    e.value = value;
                    return;
                }

                if (k == null) {//如果key为null,用新key、value覆盖,同时清理历史key=null的陈旧数据
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
            //ThreadLocal对应的key实例不存在也没有陈旧元素,new 一个
            tab[i] = new Entry(key, value);
            int sz = ++size;
            // // 如果没有清理陈旧的 Entry 并且数组中的元素大于了阈值,则进行rehash
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }
        
        //重新哈希
        private void rehash() {
            expungeStaleEntries();//清理一次陈旧数据  保证数据及时 GC

            // 清理完陈旧数据,如果size >= 3/4阀值,就执行扩容,避免迟滞
            if (size >= threshold - threshold / 4)
                resize();
        }

        /**
         * 把table扩容2倍,并把老数据重新哈希散列进新table
         */
        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) {// 如果key=null
                        e.value = null; // 把value也置null,有助于GC回收对象
                    } else {
                        int h = k.threadLocalHashCode & (newLen - 1);
                        while (newTab[h] != null)
                            h = nextIndex(h, newLen);
                        newTab[h] = e;
                        count++;
                    }
                }
            }

            setThreshold(newLen);;// 设置新的阈值(实际set方法用了2/3的newLen作为阈值)
            size = count;/ 设置ThreadLocalMap的元素个数
            table = newTab;// 把新table赋值给ThreadLocalMap的Entry[] table
        }

⑤remove

        /**
         * Remove the entry for key.
         */
        private void remove(ThreadLocal<?> key) {
            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)]) {
                if (e.get() == key) {
                    e.clear();//此处entry的clear实际会把引用置为null(也就是entry的key置null)
                    expungeStaleEntry(i);//删除陈旧entry
                    return;
                }
            }
        }

 

3、ThreadLocal

来看一下ThreadLocal主要的方法:

//返回ThreadLocal的初始值。这个方法将在线程第一次使用{@link #get}方法
//访问变量时调用,除非线程之前调用了{@link #set}方法,
//在这种情况下,将不会为线程调用{@code initialValue}方法
protected T initialValue() {
        return null;
}
//返回当前线程ThreadLocalMap中ThreadLocal对应的value    
public T get() {
        Thread t = Thread.currentThread();//获取当前线程
        ThreadLocalMap map = getMap(t);//获取线程的ThreadLocalMap变量
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;//不为空直接返回
            }
        }
        return setInitialValue();//为空设置初始值后返回
    }

//获取当前线程所对应的ThreadLocalMap
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    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);//为空创建ThreadLocalMap 
        return value;
    }

    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    
     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);//调用ThreadLocalMap删除变量
     }

4、关于 ThreadLocal内存泄漏问题(摘自【细谈Java并发】谈谈ThreadLocal

ThreadLocalMap使用ThreadLocal的弱引用作为key,如果一个ThreadLocal没有外部强引用来引用它,那么系统 GC 的时候,这个ThreadLocal势必会被回收,这样一来,ThreadLocalMap中就会出现key为null的Entry,就没有办法访问这些key为null的Entry的value,如果当前线程再迟迟不结束的话,这些key为null的Entry的value就会一直存在一条强引用链:Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永远无法回收,造成内存泄漏。

其实,ThreadLocalMap的设计中已经考虑到这种情况,也加上了一些防护措施:在ThreadLocal的get(),set(),remove()的时候都会清除线程ThreadLocalMap里所有key为null的value。

但是这些被动的预防措施并不能保证不会内存泄漏:

  • 使用线程池的时候,这个线程执行任务结束,ThreadLocal对象被回收了,线程放回线程池中不销毁,这个线程一直不被使用,导致内存泄漏。
  • 分配使用了ThreadLocal又不再调用get(),set(),remove()方法,那么这个期间就会发生内存泄漏。

5、为什么使用弱引用(摘自【细谈Java并发】谈谈ThreadLocal​​​​​​​)

从表面上看内存泄漏的根源在于使用了弱引用。网上的文章大多着重分析为什么会内存泄漏,但是另一个问题也同样值得思考:为什么使用弱引用?为什么不用强引用?

我们先来看看官方文档的说法:

To help deal with very large and long-lived usages, the hash table entries use WeakReferences for keys.
为了应对非常大和长时间的用途,哈希表使用弱引用的 key。

下面我们分两种情况讨论:

  • key 使用强引用:引用的ThreadLocal的对象被回收了,但是ThreadLocalMap还持有ThreadLocal的强引用,如果没有手动删除,ThreadLocal不会被回收,导致Entry内存泄漏。
  • key 使用弱引用:引用的ThreadLocal的对象被回收了,由于ThreadLocalMap持有ThreadLocal的弱引用,即使没有手动删除,ThreadLocal也会被回收。value在下一次ThreadLocalMap调用set,get的时候会被清除。

比较两种情况,我们可以发现:由于ThreadLocalMap的生命周期跟Thread一样长,如果都没有手动删除对应key,都会导致内存泄漏,但是使用弱引用可以多一层保障:弱引用ThreadLocal不会内存泄漏,对应的value在下一次ThreadLocalMap调用set,get,remove的时候会被清除。

因此,ThreadLocal内存泄漏的根源是:由于ThreadLocalMap的生命周期跟Thread一样长,如果没有手动删除对应key就会导致内存泄漏,而不是因为弱引用。

6、总结(摘自【细谈Java并发】谈谈ThreadLocal​​​​​​​)

怎么避免内存泄漏呢?每次使用完ThreadLocal,都调用它的remove()方法,清除数据。

在使用线程池的情况下,没有及时清理ThreadLocal,不仅是内存泄漏的问题,更严重的是可能导致业务逻辑出现问题。所以,使用ThreadLocal就跟加锁完要解锁一样,用完就清理。

 

 

评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值