细数ThreadLocal三大坑,内存泄露仅是小儿科

开发 后端
ThreadLocal写错难,但是用错就很容易,本文将会详细总结ThreadLocal容易用错的三个坑。

 

[[398500]]

 我在参加Code Review的时候不止一次听到有同学说:我写的这个上下文工具没问题,在线上跑了好久了。其实这种想法是有问题的,ThreadLocal写错难,但是用错就很容易,本文将会详细总结ThreadLocal容易用错的三个坑:

内存泄露

线程池中线程上下文丢失

并行流中线程上下文丢失

内存泄露

由于ThreadLocal的key是弱引用,因此如果使用后不调用remove清理的话会导致对应的value内存泄露。 

  1. @Test  
  2. public void testThreadLocalMemoryLeaks() {  
  3.     ThreadLocal<List<Integer>> localCache = new ThreadLocal<>();  
  4.    List<Integer> cacheInstance = new ArrayList<>(10000);  
  5.     localCache.set(cacheInstance);  
  6.     localCache = new ThreadLocal<>();  

当localCache的值被重置之后cacheInstance被ThreadLocalMap中的value引用,无法被GC,但是其key对ThreadLocal实例的引用是一个弱引用,本来ThreadLocal的实例被localCache和ThreadLocalMap的key同时引用,但是当localCache的引用被重置之后,则ThreadLocal的实例只有ThreadLocalMap的key这样一个弱引用了,此时这个实例在GC的时候能够被清理。

其实看过ThreadLocal源码的同学会知道,ThreadLocal本身对于key为null的Entity有自清理的过程,但是这个过程是依赖于后续对ThreadLocal的继续使用,假如上面的这段代码是处于一个秒杀场景下,会有一个瞬间的流量峰值,这个流量峰值也会将集群的内存打到高位(或者运气不好的话直接将集群内存打满导致故障),后面由于峰值流量已过,对ThreadLocal的调用也下降,会使得ThreadLocal的自清理能力下降,造成内存泄露。ThreadLocal的自清理是锦上添花,千万不要指望他雪中送碳。

相比于ThreadLocal中存储的value对象泄露,ThreadLocal用在web容器中时更需要注意其引起的ClassLoader泄露。

Tomcat官网对在web容器中使用ThreadLocal引起的内存泄露做了一个总结,详见:https://cwiki.apache.org/confluence/display/tomcat/MemoryLeakProtection,这里我们列举其中的一个例子。

熟悉Tomcat的同学知道,Tomcat中的web应用由Webapp Classloader这个类加载器的,并且Webapp Classloader是破坏双亲委派机制实现的,即所有的web应用先由Webapp classloader加载,这样的好处就是可以让同一个容器中的web应用以及依赖隔离。

下面我们看具体的内存泄露的例子: 

  1. public class MyCounter {  
  2.  private int count = 0 
  3.  public void increment() {  
  4.   count++;  
  5.  }  
  6.  public int getCount() {  
  7.   return count;  
  8.  }  
  9.  
  10. public class MyThreadLocal extends ThreadLocal<MyCounter> {  
  11.  
  12. public class LeakingServlet extends HttpServlet {  
  13.  private static MyThreadLocal myThreadLocal = new MyThreadLocal();  
  14.  protected void doGet(HttpServletRequest request,  
  15.    HttpServletResponse response) throws ServletException, IOException {  
  16.   MyCounter counter = myThreadLocal.get();  
  17.   if (counter == null) {  
  18.    counter = new MyCounter();  
  19.    myThreadLocal.set(counter);  
  20.   }  
  21.   response.getWriter().println(  
  22.     "The current thread served this servlet " + counter.getCount()  
  23.       + " times"); 
  24.    counter.increment();  
  25.  }  

需要注意这个例子中的两个非常关键的点:

MyCounter以及MyThreadLocal必须放到web应用的路径中,保被Webapp Classloader加载

ThreadLocal类一定得是ThreadLocal的继承类,比如例子中的MyThreadLocal,因为ThreadLocal本来被Common Classloader加载,其生命周期与Tomcat容器一致。ThreadLocal的继承类包括比较常见的NamedThreadLocal,注意不要踩坑。

假如LeakingServlet所在的Web应用启动,MyThreadLocal类也会被Webapp Classloader加载,如果此时web应用下线,而线程的生命周期未结束(比如为LeakingServlet提供服务的线程是一个线程池中的线程),那会导致myThreadLocal的实例仍然被这个线程引用,而不能被GC,期初看来这个带来的问题也不大,因为myThreadLocal所引用的对象占用的内存空间不太多,问题在于myThreadLocal间接持有加载web应用的webapp classloader的引用(通过myThreadLocal.getClass().getClassLoader()可以引用到),而加载web应用的webapp classloader有持有它加载的所有类的引用,这就引起了Classloader泄露,它泄露的内存就非常可观了。

线程池中线程上下文丢失

ThreadLocal不能在父子线程中传递,因此最常见的做法是把父线程中的ThreadLocal值拷贝到子线程中,因此大家会经常看到类似下面的这段代码: 

  1. for(value in valueList){  
  2.      Future<?> taskResult = threadPool.submit(new BizTask(ContextHolder.get()));//提交任务,并设置拷贝Context到子线程  
  3.      results.add(taskResult);  
  4.  
  5. for(result in results){  
  6.     result.get();//阻塞等待任务执行完成  

提交的任务定义长这样: 

  1. class BizTask<T> implements Callable<T>  {  
  2.     private String session = null;     
  3.     public BizTask(String session) {  
  4.         this.session = session;  
  5.     }      
  6.     @Override  
  7.     public T call(){ 
  8.          try {  
  9.             ContextHolder.set(this.session);  
  10.             // 执行业务逻辑  
  11.         } catch(Exception e){  
  12.             //log error  
  13.         } finally {  
  14.             ContextHolder.remove(); // 清理 ThreadLocal 的上下文,避免线程复用时context互串  
  15.         }  
  16.         return null;  
  17.     }  

对应的线程上下文管理类为: 

  1. class ContextHolder {  
  2.     private static ThreadLocal<String> localThreadCache = new ThreadLocal<>();     
  3.     public static void set(String cacheValue) {  
  4.         localThreadCache.set(cacheValue); 
  5.     }      
  6.     public static String get() {  
  7.         return localThreadCache.get();  
  8.     }      
  9.     public static void remove() {  
  10.         localThreadCache.remove();  
  11.     }     

这么写倒也没有问题,我们再看看线程池的设置: 

  1. ThreadPoolExecutor executorPool = new ThreadPoolExecutor(20, 40, 30, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(40), new XXXThreadFactory(), ThreadPoolExecutor.CallerRunsPolicy); 

其中最后一个参数控制着当线程池满时,该如何处理提交的任务,内置有4种策略 

  1. ThreadPoolExecutor.AbortPolicy //直接抛出异常  
  2. ThreadPoolExecutor.DiscardPolicy //丢弃当前任务  
  3. ThreadPoolExecutor.DiscardOldestPolicy //丢弃工作队列头部的任务  
  4. ThreadPoolExecutor.CallerRunsPolicy //转串行执行 

可以看到,我们初始化线程池的时候指定如果线程池满,则新提交的任务转为串行执行,那我们之前的写法就会有问题了,串行执行的时候调用ContextHolder.remove();会将主线程的上下文也清理,即使后面线程池继续并行工作,传给子线程的上下文也已经是null了,而且这样的问题很难在预发测试的时候发现。

并行流中线程上下文丢失

如果ThreadLocal碰到并行流,也会有很多有意思的事情发生,比如有下面的代码: 

  1. class ParallelProcessor<T> {   
  2.     public void process(List<T> dataList) {  
  3.         // 先校验参数,篇幅限制先省略不写  
  4.         dataList.parallelStream().forEach(entry -> {  
  5.             doIt();  
  6.         }); 
  7.     } 
  8.      private void doIt() {  
  9.         String session = ContextHolder.get();  
  10.         // do something  
  11.     }  

这段代码很容易在线下测试的过程中发现不能按照预期工作,因为并行流底层的实现也是一个ForkJoin线程池,既然是线程池,那ContextHolder.get()可能取出来的就是一个null。我们顺着这个思路把代码再改一下: 

  1. class ParallelProcessor<T> {   
  2.      private String session;     
  3.     public ParallelProcessor(String session) {  
  4.         this.session = session;  
  5.     }      
  6.     public void process(List<T> dataList) {  
  7.         // 先校验参数,篇幅限制先省略不写  
  8.         dataList.parallelStream().forEach(entry -> {  
  9.             try {  
  10.                 ContextHolder.set(session);  
  11.                 // 业务处理  
  12.                 doIt();  
  13.             } catch (Exception e) {  
  14.                 // log it  
  15.             } finally {  
  16.                 ContextHolder.remove();  
  17.             }  
  18.         });  
  19.     }  
  20.      private void doIt() {  
  21.         String session = ContextHolder.get();  
  22.         // do something  
  23.     }  

修改完后的这段代码可以工作吗?如果运气好,你会发现这样改又有问题,运气不好,这段代码在线下运行良好,这段代码就顺利上线了。不久你就会发现系统中会有一些其他很诡异的bug。原因在于并行流的设计比较特殊,父线程也有可能参与到并行流线程池的调度,那如果上面的process方法被父线程执行,那么父线程的上下文会被清理。导致后续拷贝到子线程的上下文都为null,同样产生丢失上下文的问题,关于并行流的实现可以参考文章啥?用了并行流还更慢了。 

 

责任编辑:庞桂玉 来源: Java知音
相关推荐

2022-03-17 17:54:19

人脸识别AI人工智能

2010-01-07 15:07:34

Ubuntu Anju

2022-08-26 07:33:49

内存JVMEntry

2022-06-06 00:25:09

Golangpanic死锁

2019-08-07 06:16:28

物联网IOT技术

2021-12-28 00:27:24

运营商内卷网络

2023-06-30 08:10:14

JavaBigDecimal

2022-10-18 08:38:16

内存泄漏线程

2023-04-16 19:34:01

2017-03-30 08:42:42

技术信息安全开源

2018-04-02 07:32:15

2023-02-17 08:20:24

SQL脚本数据库

2021-04-23 20:59:02

ThreadLocal内存

2022-05-15 08:13:50

Mysql数据库Mycat

2015-11-20 10:39:31

2018-07-19 16:00:25

2017-07-21 07:37:20

2010-11-08 13:39:05

网宿科技B2C企业网站

2021-09-26 09:16:45

RedisGeo 类型数据类型

2023-11-03 08:10:49

ThreadLoca内存泄露
点赞
收藏

51CTO技术栈公众号