美文网首页
ThreadLocal 源码解读

ThreadLocal 源码解读

作者: Always_July | 来源:发表于2021-10-27 20:27 被阅读0次

    ThreadLocal 翻译就是线程局部变量,就是这个变量只存在于当前的线程,只存在于当前的线程,那么完美解决了并发共享资源导致并发不安全的问题。

    java.lang.ThreadLocal#get

        /**
         * Returns the value in the current thread's copy of this
         * thread-local variable.  If the variable has no value for the
         * current thread, it is first initialized to the value returned
         * by an invocation of the {@link #initialValue} method.
         *
         * @return the current thread's value of this thread-local
         */
        public T get() {
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t); // 1
            if (map != null) {
                ThreadLocalMap.Entry e = map.getEntry(this); 
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    T result = (T)e.value;
                    return result;
                }
            }
            return setInitialValue();
        }
       
        ThreadLocalMap getMap(Thread t) {
            return t.threadLocals;
        }
    

    // 1 从当前线程获取一个ThreadLocalMap,ThreadLocalMap.java是Thread中的一个静态内部类,让我们看一下ThreadLocalMap.Entry类。

    java.lang.ThreadLocal.ThreadLocalMap.Entry

     /**
             * The entries in this hash map extend WeakReference, using
             * its main ref field as the key (which is always a
             * ThreadLocal object).  Note that null keys (i.e. entry.get()
             * == null) mean that the key is no longer referenced, so the
             * entry can be expunged from table.  Such entries are referred to
             * as "stale entries" in the code that follows.
             */
    static class Entry extends WeakReference<ThreadLocal<?>> {
                /** The value associated with this ThreadLocal. */
                Object value;
    
                Entry(ThreadLocal<?> k, Object v) {
                    super(k);  // 1
                    value = v;
                }
            }
    

    注释中说道当entry.get() == null 代表key不再被引用,这个entry可以从table中释放了,也可以看到Entry.java继承了WeakReference.java(弱引用)

    弱引用概念

    弱引用也是用来描述那些非必须对象,但是它的强度比软引用更弱一些,被弱引用关联的对象只
    能生存到下一次垃圾收集发生为止。当垃圾收集器开始工作,无论当前内存是否足够,都会回收掉只被弱引用关联的对象。在JDK 1.2版之后提供了WeakReference类来实现弱引用。

    // 1 代码 super(k); 可以看出ThreadLocal 作为WeakReference的referent。那么在下一次垃圾回收时ThreadLocal会被回收掉。

    让我们理一下引用关系 Thread->ThreadLocalMap-> Entry[]->Entry-> ThreadLocal 和 Value。ThreadLocal回收后,看一下getEntry方法,发现getEntry方法将无法获取到Entry,也就无法获取到value。此时这个value无法被获取的,也就是发生了内存泄漏。

    java.lang.ThreadLocal.ThreadLocalMap#getEntry

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

    如果当前ThreadLocal匹配不到key,那么将调用getEntryAfterMiss方法。

    java.lang.ThreadLocal.ThreadLocalMap#getEntryAfterMiss

     /**
             * Version of getEntry method for use when key is not found in
             * its direct hash slot.
             *
             * @param  key the thread local object
             * @param  i the table index for key's hash code
             * @param  e the entry at table[i]
             * @return the entry associated with key, or null if no such
             */
            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)  // 1 key为null,释放Entry。
                        expungeStaleEntry(i);
                    else
                        i = nextIndex(i, len);
                    e = tab[i];
                }
                return null;
            }
    
    

    注释:for use when key is not found in its direct hash slot。
    // 1 key为null,释放Entry。

    java.lang.ThreadLocal.ThreadLocalMap#expungeStaleEntry

     /**
             * Expunge a stale entry by rehashing any possibly colliding entries
             * lying between staleSlot and the next null slot.  This also expunges
             * any other stale entries encountered before the trailing null.  See
             * Knuth, Section 6.4
             *
             * @param staleSlot index of slot known to have null key
             * @return the index of the next null slot after staleSlot
             * (all between staleSlot and this slot will have been checked
             * for expunging).
             */
            private int expungeStaleEntry(int staleSlot) {
                Entry[] tab = table;
                int len = tab.length;
    
                // expunge entry at staleSlot
                tab[staleSlot].value = null;
                tab[staleSlot] = null;
                size--;
    
                // Rehash until we encounter null
                Entry e;
                int i;
                for (i = nextIndex(staleSlot, len);
                     (e = tab[i]) != null;
                     i = nextIndex(i, len)) {
                    ThreadLocal<?> k = e.get();
                    if (k == null) {
                        e.value = null;
                        tab[i] = null;
                        size--;
                    } else {
                        int h = k.threadLocalHashCode & (len - 1);
                        if (h != i) {
                            tab[i] = null;
    
                            // Unlike Knuth 6.4 Algorithm R, we must scan until
                            // null because multiple entries could have been stale.
                            while (tab[h] != null)
                                h = nextIndex(h, len);
                            tab[h] = e;
                        }
                    }
                }
                return i;
            }
    

    这里不禁让人思考为什么这里要使用WeakReference?是有助于避免内存泄漏吗?

    使用WeakReference,可以在ThreadLocal是弱引用时回收。value在java.lang.ThreadLocal.ThreadLocalMap#getEntryAfterMiss ,java.lang.ThreadLocal.ThreadLocalMap#expungeStaleEntry 方法中进行回收掉。

    每次调用完成后都调用ThreadLocal.remove() 方法完全可以避免这个内存泄漏问题。

    真正的内存泄漏的情况

    当threadLocal对象设为null时,value再也无法获取到,发生了内存泄漏,然后使用线程池,这个线程结束,线程放回线程池中不销毁,这个线程一直不被使用,或者分配使用了又不再调用ThreadLocal.get,ThreadLocal.set方法,那么这时就会发生真正的内存泄露。

    内存泄漏的Demo

    环境:java1.8
    虚拟机启动参数:-Xms64M -Xmx64M

    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    public class ThreadLocalMemoryLeak {
    
        private static ExecutorService executorService = Executors.newFixedThreadPool(100);
    
        public static void main(String[] args) throws InterruptedException, NoSuchFieldException, IllegalAccessException {
    
            for (int i = 0; i <80 ; i++) {
                // 等待垃圾回收执行
                Thread.sleep(100);
    
                ThreadLocal<ByteObject> threadLocal = new ThreadLocal<ByteObject>(){
                    @Override
                    protected ByteObject initialValue() {
                        return new ByteObject();
                    }
                };
                executorService.execute(()->{
                    threadLocal.get();
                    // 不remove将导致内存溢出
                    //threadLocal.remove();
                });
    
            }
            Thread.sleep(3000);
            executorService.shutdown();
        }
    
        public static class ByteObject{
            // 5MB
            private byte [] bytes = new byte[5*1024*1024];
    
            @Override
            protected void finalize() throws Throwable {
                System.out.println(" finalize");
            }
        }
    }
    
    
    

    注释掉remove代码,将导致内存溢出。threadLocal初始化代码 放在for循环里,for循环后不再被引用,在垃圾回收的时候将释放内存。因为线程词核心线程数100 大于需要的线程数80,不会触发在同一个线程调用get方法,所以导致ByteObject不会被释放而内存溢出。

    如果将核心线程池改为1,此时无需remove,也不会存在内存溢出的情况,因为重复调用同一个线程的get方法,所以也会触发回收ByteObject。

    在for循环开始初我sleep 100 毫秒,让垃圾回收有时间进行,否则,即使不注释掉remove也会导致内存溢出。

    参考资料

    ThreadLocal (Java Platform SE 8 )
    关于Java中的WeakReference
    ThreadLocal源码解读

    相关文章

      网友评论

          本文标题:ThreadLocal 源码解读

          本文链接:https://www.haomeiwen.com/subject/nnspaltx.html