ThreadLocal 的用法以及内存泄露（内存溢出）

旧城等待， 2022-03-19 16:15 486阅读 0赞

ThreadLocal 看名字 就可以看出一点头绪来，线程本地。  
来看一下java对他的描述：

**该类提供线程本地变量。**这些变量与它们的正常对应变量的不同之处在于，**每个线程(通过ThreadLocal的 get 或 set方法)访问自己的、独立初始化的变量副本。** ThreadLocal实例通常是类中的**私有静态字段**。

上面这段话呢，一个重点就是 每个线程都有自己的专属变量，**这个专属变量呢，是不会被其他线程影响的**。

# 使用 #

public class ThreadLocalTwo { 
        //静态的 延长生命周期。final 不可改变
        private static final ThreadLocal<Integer> threalLocal = ThreadLocal.withInitial(() -> { 
            return 0;
        });
    
        public static void main(String[] args) { 
            new Thread(() -> { 
                while (true) { 
                    //取出来
                    int inner = threalLocal.get();
                    //使用
                    System.out.println(Thread.currentThread().getName() + " " + inner);
                    LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(1));
                    //更新值存入
                    threalLocal.set(++inner);
                }
            }, "three").start();
    
            new Thread(() -> { 
                while (true) { 
                    //取出来
                    int inner = threalLocal.get();
                    //使用
                    System.out.println(Thread.currentThread().getName() + " " + inner);
                    LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(1));
                    //更新值存入
                    threalLocal.set(++inner);
                }
            }, "four").start();
        }
    }

使用这个我只是随便写一个demo，具体的逻辑有很多种，只要你想，就会有很多种写法。具体看业务需求。

**个人理解**  
**ThreadLocal 类似于一个工具，通过这个工具，来为当前线程设定修改移除本地副本。**，如果 你查看Thread的源码会发现下面这段代码

/* ThreadLocal values pertaining to this thread. This map is maintained by the ThreadLocal class. */
        ThreadLocal.ThreadLocalMap threadLocals = null;

这是静态内部类构造的一个字段，那么我们看一下 ThreadLocal.ThreadLocalMap的源码.

static class Entry extends WeakReference<ThreadLocal<?>> { 
                /** The value associated with this ThreadLocal. */
                Object value;
    
                Entry(ThreadLocal<?> k, Object v) { 
                    super(k);
                    value = v;
                }
            }
            
            /** * The table, resized as necessary. * table.length MUST always be a power of two. */
            private Entry[] table;

上面代码我们可以发现 ThreadLocal.ThreadLocalMap这个内部静态类，里面还包含这一个内部静态类Entry。  
这个Entry 继承了WeakReference,并且将ThreadLocal作为弱引用类型。**这表明 ThreadLocal如果没有其他的强引用时候，说不定 有可能不知道啥时候就被回收了。**  
那么至于 value呢? **我可以肯定的告诉你 value不会被回收，即便 传进来的v是个匿名类。**  
**value持有着线程的本地副本的引用**  
Entry\[\] table 这个持有 entry的引用

题外话 WeakReference也是有很多知识点的，这个可以看[java 内存回收和四种引用关系\_SoftReference,WeakReference,PhantomReference][java _SoftReference_WeakReference_PhantomReference]  
现在 ，只需要知道  
1 **弱引用对象，会持有引用对象的引用，弱引用对象并不能决定 引用对象是否回收。**  
2 **弱引用的子类的 如果有自己的字段的话， 那么那个字段是强引用，不会被回收**  
3 弱引用对象，**如果是new出来的，那么弱引用对象本身也是一个强引用。弱引用对象自己不会被回收**。

# 构造方法 #

一个默认的无参构造方法 ，没啥好讲的，，

public ThreadLocal() { 
        }

使用

private static final ThreadLocal<String> construct  = new ThreadLocal<>(){ 
            //如果 不重写这个方法的话，默认返回null
            @Override
            protected String initialValue() { 
                return "默认值";
            }
        };

## 静态方法 ##

**note Java8新增的方法**

public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) { 
            return new SuppliedThreadLocal<>(supplier);
        }

上面的这个静态方法呢，生成一个ThreadLocal对象，参数是一个Supplier函数接口。  
下面展示一个代码

private static final ThreadLocal<String> local = ThreadLocal.withInitial(() -> "默认值");

**上面这段代码使用了Lambda表达式， 比起上面 new 并且重写方法的写法，代码会少很多，显得很有逼格对不。**  
**如果你对java8的Lambda不清楚的话，可以看我以前的博客。**[java Lambda表达式的使用][java Lambda]

## 公共方法 ##

//返回当前线程本地副本的值。如果本地副本为null，则返回初始化为调用\{@link \#initialValue\}方法返回的值。  
public T get()

//将当前线程的本地副本 设为 value  
public void set(T value)

//将当前线程的本地副本移除，如果后面调用get()方法的话，会返回T initialValue()的值  
public void remove()

# 内存泄露 #

接下来讲一下，**ThreadLocal配合线程池时候** 会出现内存泄漏的原理。按照我的个人理解 ，**是因为内存溢出造成的。**内存泄露指的是 原本应该回收的对象，现在由于种种原因，无法被回收。

为什么上面会强调 配合线程池的时候，**因为单独线程的时候，当线程任务运行完以后，线程资源会被回收，自然 本地副本也被回收了。**而**线程池里面的线程不全被回收（有的不会被回收，也有的会被回收）**。

现在来看一下上面的Entry这个最终存储本地副本的静态内部类，

**下面内容需要你对 java 内存管理关系了解，否则 你肯定会一脸蒙蔽。**  
如果 你不会 可以看我这篇博客[java内存管理关系及内存泄露 原理][java_]

由于它是WeakReference的子类，所以 **作为引用对象的 ThreadLocal，就有可能会被Entry清除引用。如果这时候 ThreadLocal没有其他的引用，那么它肯定就会被GC回收了。**

但是**value 是强引用**，而**Entry 又被Entry\[\]持有**，**Entry\[\]又被ThreadLocalMap持有**，**ThreadLocalMap又被线程持有**。**只要线程不死或者 你不调用set，remove这两个方法之中任何一个**，那么**value指向的这个对象**就始终 不会被回收。因为 不符合GC回收的两个条件的任何一个。

**试想一下如果线程池里面的线程足够的多，并且 你传给线程的本地副本内存占用又很大。毫无疑问 会内存溢出。**

# 解决方法 #

**只要调用remove 这个方法会擦出 上一个value的引用，这样线程就不会持有上一个value指向对象的引用。**就不会有内存露出了。

**有读者会有疑问了，上面不是说两个放过会使value对象可以回收么，怎么上面没有set方法呢？**  
这个是因为，**set方法确实可以是value指向的对象 这个引用断开，但同时它又强引用了一个内存空间给value。**即使上一个对象被回收了，但是新对象也产生了。

至于 get方法，只有在ThreadLocalMap 被GC后，调用get方法 才会将value对应的引用切断。

#### 首先，我们看get源码 ####

public T get() { 
            Thread t = Thread.currentThread();//当前线程的引用
            //得到当前线程的ThreadLocalMap，如果没有返回null
            ThreadLocalMap map = getMap(t);
            //存在时候走这个
            if (map != null) { 
                 //与键关联的项，如果没有键则为null 
                 //如果ThreadLocalMap的entry 清除了ThreadLocal 对象的引用，那么这个会清除对应的value 引用
                ThreadLocalMap.Entry e = map.getEntry(this);
                if (e != null) { 
                    @SuppressWarnings("unchecked")
                    T result = (T)e.value;
                    return result;
                }
            }
            //当前线程 没有设置ThreadLocalMap，那么返回initialValue()的值
            return setInitialValue();
        }

上面这段代码，调用了getEntry，这个方法内部调用了 另一个方法，**实现了当ThreadLocal被清除引用后，也清除对应的value引用，**

private Entry getEntry(ThreadLocal<?> key) { 
                //得到位置 table数组 的容量是16
                int i = key.threadLocalHashCode & (table.length - 1);
                Entry e = table[i];
                 //key没有被回收后
                if (e != null && e.get() == key)
                    return e;
                else
                     //这个key被回收 调用，将对应的value 释放引用
                    return getEntryAfterMiss(key, i, e);
            }

我们看见最后调用 getEntryAfterMiss(key, i, e)，这个方法 也不是最终的擦除value引用的方法，我们接着往下看

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) { 
                Entry[] tab = table;
                int len = tab.length;
                while (e != null) { 
                     //得到弱引用对象 持有的引用对象的引用
                    ThreadLocal<?> k = e.get();
                    //ThreadLocal没有被回收
                    if (k == key)
                        return e;
                    
                    if (k == null)
                        //entry 清除ThreadLocal的引用 
                       //通过entry[]数组的元素entry 清除entry的value引用
                        expungeStaleEntry(i);
                    else
                        i = nextIndex(i, len);
                    e = tab[i];
                }
                return null;
            }

这上面呢，**我们要关注expungeStaleEntry(i)，这个才是最终的擦除entry的value对象的引用。** 看一下 expungeStaleEntry(i)的源码

private int expungeStaleEntry(int staleSlot) { 
                Entry[] tab = table;//得到table引用
                int len = tab.length;//得到table的长度，不出意外 应该是16
    
                // 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;
            }

上面这段代码很长，我们不必细看个，关注下面这两行代码就行

tab[staleSlot].value = null;//清除引用 这样 GC就可以回收了
                tab[staleSlot] = null;//清除自身的引用

**通过entry\[staleSlot\]得到存储的entry ，通过entry清除entry的value引用。**  
这样大家明白了吧，get也是可以起到和remove一样的效果的。

#### 我们再看一下remove的源码 ####

public void remove() { 
             ThreadLocalMap m = getMap(Thread.currentThread());
             if (m != null)
                 m.remove(this);
         }

上面这段代码没什么说的，直接看ThreadLocalMap的remove方法

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)]) { 
                     //这里有可能会发生 ThreadLocal 被entry清除引用，那么value就被线程引用了，如果不调用set，get方法的话，只能等待线程销毁。
                    if (e.get() == key) { 
                        //调用弱引用的方法 ， 将引用对象的引用清除
                        e.clear();
                        //擦出ThreadLocal 对应的value
                        expungeStaleEntry(i);
                        return;
                    }
                }
            }

上面调用了 expungeStaleEntry 擦除。

#### set ####

我们关注这个方法

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

这个呢 循环调用了expungeStaleEntry(j)方法 ，也是擦除了value的对象引用。

## 为什么要将ThreadLocal 定义成 static 变量 ##

延长生命周期，之所以是static 是因为，**ThreadLocal 我们更应该将他看成是 工具。**

[java _SoftReference_WeakReference_PhantomReference]: https://blog.csdn.net/a1064072510/article/details/88373016
[java Lambda]: https://blog.csdn.net/a1064072510/article/details/80947286
[java_]: https://blog.csdn.net/a1064072510/article/details/83148538