文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

ThreadLocal内存溢出代码演示和原因分析!

2024-12-03 04:36

关注

前言

ThreadLocal 翻译成中文是线程本地变量的意思,也就是说它是线程中的私有变量,每个线程只能操作自己的私有变量,所以不会造成线程不安全的问题。

所谓的线程不安全是指,多个线程在同一时刻对同一个全局变量做写操作时(读操作不会涉及线程不安全问题),如果执行的结果和我们预期的结果不一致就称之为线程不安全,反之,则称为线程安全。

在 Java 语言中解决线程不安全的问题通常有两种手段:

锁的实现方案是在多线程写入全局变量时,通过排队一个一个来写入全局变量,从而就可以避免线程不安全的问题了。比如当我们使用线程不安全的 SimpleDateFormat 对时间进行格式化时,如果使用锁来解决线程不安全的问题,实现的流程就是这样的:

从上述图片可以看出,通过加锁的方式虽然可以解决线程不安全的问题,但同时带来了新的问题,使用锁时线程需要排队执行,因此会带来一定的性能开销。然而,如果使用的是 ThreadLocal 的方式,则是给每个线程创建一个 SimpleDateFormat 对象,这样就可以避免排队执行的问题了,它的实现流程如下图所示:

然而,在我们使用 ThreadLocal 的过程中,很容易就会出现内存溢出的问题,如下面的这个事例。

什么是内存溢出?

内存溢出(Out Of Memory,简称 OOM)是指无用对象(不再使用的对象)持续占有内存,或无用对象的内存得不到及时释放,从而造成的内存空间浪费的行为就称之为内存泄露。

内存溢出代码演示

在开始演示 ThreadLocal 内存溢出的问题之前,我们先使用“-Xmx50m”的参数来设置一下 Idea,它表示将程序运行的最大内存设置为 50m,如果程序的运行超过这个值就会出现内存溢出的问题,设置方法如下:

设置后的最终效果这样的:

配置完 Idea 之后,接下来我们来实现一下业务代码。在代码中我们会创建一个大对象,这个对象中会有一个 10m 大的数组,然后我们将这个大对象存储在 ThreadLocal 中,再使用线程池执行大于 5 次添加任务,因为设置了最大运行内存是 50m,所以理想的情况是执行 5 次添加操作之后,就会出现内存溢出的问题,实现代码如下:

  1. import java.util.concurrent.LinkedBlockingQueue; 
  2. import java.util.concurrent.ThreadPoolExecutor; 
  3. import java.util.concurrent.TimeUnit; 
  4.  
  5. public class ThreadLocalOOMExample { 
  6.      
  7.      
  8.     static class MyTask { 
  9.         // 创建一个 10m 的数组(单位转换是 1M -> 1024KB -> 1024*1024B) 
  10.         private byte[] bytes = new byte[10 * 1024 * 1024]; 
  11.     } 
  12.      
  13.     // 定义 ThreadLocal 
  14.     private static ThreadLocal taskThreadLocal = new ThreadLocal<>(); 
  15.  
  16.     // 主测试代码 
  17.     public static void main(String[] args) throws InterruptedException { 
  18.         // 创建线程池 
  19.         ThreadPoolExecutor threadPoolExecutor = 
  20.                 new ThreadPoolExecutor(5, 5, 60, 
  21.                         TimeUnit.SECONDS, new LinkedBlockingQueue<>(100)); 
  22.         // 执行 10 次调用 
  23.         for (int i = 0; i < 10; i++) { 
  24.             // 执行任务 
  25.             executeTask(threadPoolExecutor); 
  26.             Thread.sleep(1000); 
  27.         } 
  28.     } 
  29.  
  30.      
  31.     private static void executeTask(ThreadPoolExecutor threadPoolExecutor) { 
  32.         // 执行任务 
  33.         threadPoolExecutor.execute(new Runnable() { 
  34.             @Override 
  35.             public void run() { 
  36.                 System.out.println("创建对象"); 
  37.                 // 创建对象(10M) 
  38.                 MyTask myTask = new MyTask(); 
  39.                 // 存储 ThreadLocal 
  40.                 taskThreadLocal.set(myTask); 
  41.                 // 将对象设置为 null,表示此对象不在使用了 
  42.                 myTask = null
  43.             } 
  44.         }); 
  45.     } 

以上程序的执行结果如下:

从上述图片可看出,当程序执行到第 5 次添加对象时就出现内存溢出的问题了,这是因为设置了最大的运行内存是 50m,每次循环会占用 10m 的内存,加上程序启动会占用一定的内存,因此在执行到第 5 次添加任务时,就会出现内存溢出的问题。

原因分析

内存溢出的问题和解决方案比较简单,重点在于“原因分析”,我们要通过内存溢出的问题搞清楚,为什么 ThreadLocal 会这样?是什么原因导致了内存溢出?

要搞清楚这个问题(内存溢出的问题),我们需要从 ThreadLocal 源码入手,所以我们首先打开 set 方法的源码(在示例中使用到了 set 方法),如下所示:

  1. public void set(T value) { 
  2.     // 得到当前线程 
  3.     Thread t = Thread.currentThread(); 
  4.     // 根据线程获取到 ThreadMap 变量 
  5.     ThreadLocalMap map = getMap(t); 
  6.     if (map != null
  7.         map.set(this, value); // 将内容存储到 map 中 
  8.     else 
  9.         createMap(t, value); // 创建 map 并将值存储到 map 中 

从上述代码我们可以看出 Thread、ThreadLocalMap 和 set 方法之间的关系:每个线程 Thread 都拥有一个数据存储容器 ThreadLocalMap,当执行 ThreadLocal.set 方法执行时,会将要存储的值放到 ThreadLocalMap 容器中,所以接下来我们再看一下 ThreadLocalMap 的源码:

  1. static class ThreadLocalMap { 
  2.     // 实际存储数据的数组 
  3.     private Entry[] table
  4.     // 存数据的方法 
  5.     private void set(ThreadLocal key, Object value) { 
  6.         Entry[] tab = table
  7.         int len = tab.length; 
  8.         int i = key.threadLocalHashCode & (len-1); 
  9.         for (Entry e = tab[i]; 
  10.                 e != null
  11.                 e = tab[i = nextIndex(i, len)]) { 
  12.             ThreadLocal k = e.get(); 
  13.             // 如果有对应的 key 直接更新 value 值 
  14.             if (k == key) { 
  15.                 e.value = value; 
  16.                 return
  17.             } 
  18.             // 发现空位插入 value 
  19.             if (k == null) { 
  20.                 replaceStaleEntry(key, value, i); 
  21.                 return
  22.             } 
  23.         } 
  24.         // 新建一个 Entry 插入数组中 
  25.         tab[i] = new Entry(key, value); 
  26.         int sz = ++size
  27.         // 判断是否需要进行扩容 
  28.         if (!cleanSomeSlots(i, sz) && sz >= threshold) 
  29.             rehash(); 
  30.     } 
  31.     // ... 忽略其他源码 

从上述源码我们可以看出:ThreadMap 中有一个 Entry[] 数组用来存储所有的数据,而 Entry 是一个包含 key 和 value 的键值对,其中 key 为 ThreadLocal 本身,而 value 则是要存储在 ThreadLocal 中的值。

根据上面的内容,我们可以得出 ThreadLocal 相关对象的关系图,如下所示:

也就是说它们之间的引用关系是这样的:Thread -> ThreadLocalMap -> Entry -> Key,Value,因此当我们使用线程池来存储对象时,因为线程池有很长的生命周期,所以线程池会一直持有 value 值,那么垃圾回收器就无法回收 value,所以就会导致内存一直被占用,从而导致内存溢出问题的发生。

解决方案

ThreadLocal 内存溢出的解决方案很简单,我们只需要在使用完 ThreadLocal 之后,执行 remove 方法就可以避免内存溢出问题的发生了,比如以下代码:

  1. import java.util.concurrent.LinkedBlockingQueue; 
  2. import java.util.concurrent.ThreadPoolExecutor; 
  3. import java.util.concurrent.TimeUnit; 
  4.  
  5. public class App { 
  6.  
  7.      
  8.     static class MyTask { 
  9.         // 创建一个 10m 的数组(单位转换是 1M -> 1024KB -> 1024*1024B) 
  10.         private byte[] bytes = new byte[10 * 1024 * 1024]; 
  11.     } 
  12.  
  13.     // 定义 ThreadLocal 
  14.     private static ThreadLocal taskThreadLocal = new ThreadLocal<>(); 
  15.  
  16.     // 测试代码 
  17.     public static void main(String[] args) throws InterruptedException { 
  18.         // 创建线程池 
  19.         ThreadPoolExecutor threadPoolExecutor = 
  20.                 new ThreadPoolExecutor(5, 5, 60, 
  21.                         TimeUnit.SECONDS, new LinkedBlockingQueue<>(100)); 
  22.         // 执行 n 次调用 
  23.         for (int i = 0; i < 10; i++) { 
  24.             // 执行任务 
  25.             executeTask(threadPoolExecutor); 
  26.             Thread.sleep(1000); 
  27.         } 
  28.     } 
  29.  
  30.      
  31.     private static void executeTask(ThreadPoolExecutor threadPoolExecutor) { 
  32.         // 执行任务 
  33.         threadPoolExecutor.execute(new Runnable() { 
  34.             @Override 
  35.             public void run() { 
  36.                 System.out.println("创建对象"); 
  37.                 try { 
  38.                     // 创建对象(10M) 
  39.                     MyTask myTask = new MyTask(); 
  40.                     // 存储 ThreadLocal 
  41.                     taskThreadLocal.set(myTask); 
  42.                     // 其他业务代码... 
  43.                 } finally { 
  44.                     // 释放内存 
  45.                     taskThreadLocal.remove(); 
  46.                 } 
  47.             } 
  48.         }); 
  49.     } 

以上程序的执行结果如下:

从上述结果可以看出我们只需要在 finally 中执行 ThreadLocal 的 remove 方法之后就不会在出现内存溢出的问题了。

remove的秘密

那 remove 方法为什么会有这么大的魔力呢?我们打开 remove 的源码看一下:

  1. public void remove() { 
  2.     ThreadLocalMap m = getMap(Thread.currentThread()); 
  3.     if (m != null
  4.         m.remove(this); 

从上述源码中我们可以看出,当调用了 remove 方法之后,会直接将 Thread 中的 ThreadLocalMap 对象移除掉,这样 Thread 就不再持有 ThreadLocalMap 对象了,所以即使 Thread 一直存活,也不会造成因为(ThreadLocalMap)内存占用而导致的内存溢出问题了。

总结

本文我们使用代码的方式演示了 ThreadLocal 内存溢出的问题,严格来讲内存溢出并不是 ThreadLocal 的问题,而是因为没有正确使用 ThreadLocal 所带来的问题。想要避免 ThreadLocal 内存溢出的问题,只需要在使用完 ThreadLocal 后调用 remove 方法即可。不过通过 ThreadLocal 内存溢出的问题,让我们搞清楚了 ThreadLocal 的具体实现,方便我们日后更好的使用 ThreadLocal,以及更好的应对面试。

本文转载自微信公众号「Java中文社群」,可以通过以下二维码关注。转载本文请联系Java中文社群公众号。

 

来源:Java中文社群内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯