为什么ThreadLocal容易导致内存泄漏？

本文转载自微信公众号「三不猴子」，作者sanbuhouzi。转载本文请联系三不猴子公众号。

成都创新互联公司专注为客户提供全方位的互联网综合服务，包含不限于成都网站设计、成都做网站、外贸网站建设、禹会网络推广、微信小程序、禹会网络营销、禹会企业策划、禹会品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们最大的嘉奖；成都创新互联公司为所有大学生创业者提供禹会建站搭建服务，24小时服务热线：13518219792，官方网址：www.cdcxhl.com

为什么ThreadLocal容易导致内存泄漏?

ThreadLocal是什么?

官方解释为：

This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its get or set method) has its own, independently initialized copy of the variable.

我们通常创建的变量可以被任何线程访问和修改，而是用ThreadLocal创建的变量只能通过当前线程去访问和修改。

ThreadLocal原理

jdk版本1.8，我们先看一下ThreadLocal的源码，先从set方法开始。

 
 
 
 
    
  
  
  
  
  1. /** 
    2.   
  
  
  
  2.    * Sets the current thread's copy of this thread-local variable 
    3.   
  
  
  
  3.    * to the specified value.  Most subclasses will have no need to 
    4.   
  
  
  
  4.    * override this method, relying solely on the {@link #initialValue} 
    5.   
  
  
  
  5.    * method to set the values of thread-locals. 
    6.   
  
  
  
  6.    * 
    7.   
  
  
  
  7.    * @param value the value to be stored in the current thread's copy of 
    8.   
  
  
  
  8.    *        this thread-local. 
    9.   
  
  
  
  9.    */ 
    10.   
  
  
  
  10.   public void set(T value) { 
    11.   
  
  
  
  11.       Thread t = Thread.currentThread(); 
    12.   
  
  
  
  12.       ThreadLocalMap map = getMap(t); 
    13.   
  
  
  
  13.       if (map != null) 
    14.   
  
  
  
  14.           map.set(this, value); 
    15.   
  
  
  
  15.       else 
    16.   
  
  
  
  16.           createMap(t, value); 
    17.   
  
  
  
  17.   } 
    18.

这个ThreadLocalMap是ThreadLocal的一个内部类，key是当前Thread对象，value是我们要存的对象。首先拿到当前线程对象，然后获取了个map，然后往这个map中放了当前ThreadLocal对象，如果map为空则创建一个map。看看getMap的逻辑。

 
 
 
 
    
  
  
  
  
  1. /** 
    2.   
  
  
  
  2.     * Get the map associated with a ThreadLocal. Overridden in 
    3.   
  
  
  
  3.     * InheritableThreadLocal. 
    4.   
  
  
  
  4.     * 
    5.   
  
  
  
  5.     * @param  t the current thread 
    6.   
  
  
  
  6.     * @return the map 
    7.   
  
  
  
  7.     */ 
    8.   
  
  
  
  8.    ThreadLocalMap getMap(Thread t) { 
    9.   
  
  
  
  9.        return t.threadLocals; 
    10.   
  
  
  
  10.    } 
    11.

getMap就是在Thread成员变量中获取一个map。往下就是ThreadLocalMap.set()看看set的逻辑。

 
 
 
 
    
  
  
  
  
  1. /** 
    2.   
  
  
  
  2.      * Set the value associated with key. 
    3.   
  
  
  
  3.      * 
    4.   
  
  
  
  4.      * @param key the thread local object 
    5.   
  
  
  
  5.      * @param value the value to be set 
    6.   
  
  
  
  6.      */ 
    7.   
  
  
  
  7.     private void set(ThreadLocal key, Object value) { 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9.         // We don't use a fast path as with get() because it is at 
    10.   
  
  
  
  10.         // least as common to use set() to create new entries as 
    11.   
  
  
  
  11.         // it is to replace existing ones, in which case, a fast 
    12.   
  
  
  
  12.         // path would fail more often than not. 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.         Entry[] tab = table; 
    15.   
  
  
  
  15.         int len = tab.length; 
    16.   
  
  
  
  16.         int i = key.threadLocalHashCode & (len-1); 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18.         for (Entry e = tab[i]; 
    19.   
  
  
  
  19.              e != null; 
    20.   
  
  
  
  20.              e = tab[i = nextIndex(i, len)]) { 
    21.   
  
  
  
  21.             ThreadLocal k = e.get(); 
    22.   
  
  
  
  22.  
    23.   
  
  
  
  23.             if (k == key) { 
    24.   
  
  
  
  24.                 e.value = value; 
    25.   
  
  
  
  25.                 return; 
    26.   
  
  
  
  26.             } 
    27.   
  
  
  
  27.  
    28.   
  
  
  
  28.             if (k == null) { 
    29.   
  
  
  
  29.                 replaceStaleEntry(key, value, i); 
    30.   
  
  
  
  30.                 return; 
    31.   
  
  
  
  31.             } 
    32.   
  
  
  
  32.         } 
    33.   
  
  
  
  33.  
    34.   
  
  
  
  34.         tab[i] = new Entry(key, value); 
    35.   
  
  
  
  35.         int sz = ++size; 
    36.   
  
  
  
  36.         if (!cleanSomeSlots(i, sz) && sz >= threshold) 
    37.   
  
  
  
  37.             rehash(); 
    38.   
  
  
  
  38.     } 
    39.

这里构造了个Entry对象，这个Entry可以看成是map的一行数据，一个key-value对。再看看Entry的源码。

 
 
 
 
    
  
  
  
  
  1. static class Entry extends WeakReference> { 
    2.   
  
  
  
  2.             /** The value associated with this ThreadLocal. */ 
    3.   
  
  
  
  3.             Object value; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.             Entry(ThreadLocal k, Object v) { 
    6.   
  
  
  
  6.                 super(k); 
    7.   
  
  
  
  7.                 value = v; 
    8.   
  
  
  
  8.             } 
    9.   
  
  
  
  9.         } 
    10.

这个Entry对象竟然是继承了WeakReference对象。上面的流程用图画出来就是这样的。

总结起来就是：

  • 每个Thread维护着一个ThreadLocalMap的引用
  • ThreadLocalMap是ThreadLocal的内部类，用Entry来进行存储
  • 调用ThreadLocal的set()方法时，实际上就是往ThreadLocalMap设置值，key是ThreadLocal对象，value是传递进来的对象
  • 调用ThreadLocal的get()方法时，实际上就是往ThreadLocalMap获取值，key是ThreadLocal对象

ThreadLocal本身并不存储值，它只是作为一个key来让线程从ThreadLocalMap获取value。

什么是弱引用呢? 为什么ThreadLocal要使用弱引用呢?

官方文档解释为：

 
 
 
 
    
  
  
  
  
  1. /** 
    2.   
  
  
  
  2.  * Weak reference objects, which do not prevent their referents from being 
    3.   
  
  
  
  3.  * made finalizable, finalized, and then reclaimed.  Weak references are most 
    4.   
  
  
  
  4.  * often used to implement canonicalizing mappings. 
    5.   
  
  
  
  5.  * 
    6.   
  
  
  
  6.  * 
     Suppose that the garbage collector determines at a certain point in time 
    7.   
  
  
  
  7.  * that an object is weakly 
    8.   
  
  
  
  8.  * reachable.  At that time it will atomically clear all weak references to 
    9.   
  
  
  
  9.  * that object and all weak references to any other weakly-reachable objects 
    10.   
  
  
  
  10.  * from which that object is reachable through a chain of strong and soft 
    11.   
  
  
  
  11.  * references.  At the same time it will declare all of the formerly 
    12.   
  
  
  
  12.  * weakly-reachable objects to be finalizable.  At the same time or at some 
    13.   
  
  
  
  13.  * later time it will enqueue those newly-cleared weak references that are 
    14.   
  
  
  
  14.  * registered with reference queues. 
    15.   
  
  
  
  15.  * 
    16.   
  
  
  
  16.  * @author   Mark Reinhold 
    17.   
  
  
  
  17.  * @since    1.2 
    18.   
  
  
  
  18.  */ 
    19.

就是不会被程序计数器计数的引用，所以在垃圾回收器回收的时候不管是否有引用都会被回收。由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。

ThreadLocal为什么要使用弱引用?

因为当我们存入的对象被置为null的时候，也就是ThreadLocalMap的value为null，ThreadLocalMap的key是弱引用此时在下一次垃圾回收器回收垃圾的时候就可以回收掉这个key-value也是就一个Entry对象了。

既然弱引用是有助于垃圾回收的，那为什么ThreadLocal还是容易导致内存泄漏?

弱引用确实是有助于垃圾回收，但是也是有弊端的，假设我们现在存入了一个对象，此时虚拟机gc，将key弱引用回收，但是value依然是强引用，key被回收了，这个value无法通过通过ThreadLocal对象的get方法获取，它永远不会被访问到了，所以存在内存泄漏的风险。

如何避免内存泄漏

  • 在ThreadLocal使用前后都调用remove清理，同时对异常情况也要在finally中清理。 
  • 尽量不要使用全局的ThreadLocal，静态变量的生命周期和类的生命周期是一致的，而类的卸载时机可以说比较苛刻，这会导致静态ThreadLocal无法被垃圾回收，容易出现内存泄漏。

本文名称：为什么ThreadLocal容易导致内存泄漏？
文章出自：http://www.shufengxianlan.com/qtweb/news44/39744.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

虚拟主机知识

同城分类信息

蓬溪网站建设　　 　成都响应式网站建设　　 　小谭建站　　 　成都定制网站建设　　 　网站排名　　 　成都网站设计制作公司　　 　内江网站建设　　 　成都微信公众号开发　　 　成都网站推广公司　　 　胜锦安防科技　　 　西部信息中心　　 　南京护栏钻孔机　　 　网站建设　　 　成都枢纽中心　　 　成都申请ssl证书　　 　宇仓仓储　　 　网站营销推广　　 　成都响应式网站建设公司　　 　重庆网络营销　　 　ssl证书申请