ThreadLocal内存溢出演示和原因分析！

梦叶草789

发布于 2023-11-17 11:18

浏览

0收藏

前言

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

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

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

使用锁（使用 synchronized 或 Lock）；
使用 ThreadLocal。

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

ThreadLocal内存溢出演示和原因分析！-鸿蒙开发者社区

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

ThreadLocal内存溢出演示和原因分析！-鸿蒙开发者社区

PS：创建 SimpleDateFormat 也会消耗一定的时间和空间，如果线程复用 SimpleDateFormat 的频率比较高的情况下，使用 ThreadLocal 的优势比较大，反之则可以考虑使用锁。

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

什么是内存溢出？

内存溢出（Memory Overflow），指的是在程序运行过程中，申请的内存资源不再被使用，但没有被正确释放，导致占用的内存不断增加，最终耗尽系统的可用内存。当程序尝试分配更多的内存空间时，由于内存不足，会抛出 OutOfMemoryError 异常，导致程序终止或崩溃的现象就叫做内存溢出。

内存溢出代码演示

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

ThreadLocal内存溢出演示和原因分析！-鸿蒙开发者社区

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

ThreadLocal内存溢出演示和原因分析！-鸿蒙开发者社区

PS：因为我使用的 Idea 是社区版，所以可能和你的界面不一样，你只需要点击“Edit Configurations...”找到“VM options”选项，设置上“-Xmx50m”参数就可以了。

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

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

publicclass ThreadLocalOOMExample {
    
    /**
     * 定义一个 10m 大的类
     */
    staticclass MyTask {
        // 创建一个 10m 的数组（单位转换是 1M -> 1024KB -> 1024*1024B）
        privatebyte[] bytes = newbyte[10 * 1024 * 1024];
    }
    
    // 定义 ThreadLocal
    privatestatic ThreadLocal<MyTask> taskThreadLocal = new ThreadLocal<>();

    // 主测试代码
    public static void main(String[] args) throws InterruptedException {
        // 创建线程池
        ThreadPoolExecutor threadPoolExecutor =
                new ThreadPoolExecutor(5, 5, 60,
                        TimeUnit.SECONDS, new LinkedBlockingQueue<>(100));
        // 执行 10 次调用
        for (int i = 0; i < 10; i++) {
            // 执行任务
            executeTask(threadPoolExecutor);
            Thread.sleep(1000);
        }
    }

    /**
     * 线程池执行任务
     *     @param threadPoolExecutor 线程池
     */
    private static void executeTask(ThreadPoolExecutor threadPoolExecutor){
        // 执行任务
        threadPoolExecutor.execute(new Runnable() {
            @Override
            public void run(){
                System.out.println("创建对象");
                // 创建对象（10M）
                MyTask myTask = new MyTask();
                // 存储 ThreadLocal
                taskThreadLocal.set(myTask);
                // 将对象设置为 null，表示此对象不在使用了
                myTask = null;
            }
        });
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.

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

ThreadLocal内存溢出演示和原因分析！-鸿蒙开发者社区

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

原因分析

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

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

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

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

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

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

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

ThreadLocal内存溢出演示和原因分析！-鸿蒙开发者社区

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

解决方案

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

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

publicclass App {

    /**
     * 定义一个 10m 大的类
     */
    staticclass MyTask {
        // 创建一个 10m 的数组（单位转换是 1M -> 1024KB -> 1024*1024B）
        privatebyte[] bytes = newbyte[10 * 1024 * 1024];
    }

    // 定义 ThreadLocal
    privatestatic ThreadLocal<MyTask> taskThreadLocal = new ThreadLocal<>();

    // 测试代码
    public static void main(String[] args) throws InterruptedException {
        // 创建线程池
        ThreadPoolExecutor threadPoolExecutor =
                new ThreadPoolExecutor(5, 5, 60,
                        TimeUnit.SECONDS, new LinkedBlockingQueue<>(100));
        // 执行 n 次调用
        for (int i = 0; i < 10; i++) {
            // 执行任务
            executeTask(threadPoolExecutor);
            Thread.sleep(1000);
        }
    }

    /**
     * 线程池执行任务
     *     @param threadPoolExecutor 线程池
     */
    private static void executeTask(ThreadPoolExecutor threadPoolExecutor){
        // 执行任务
        threadPoolExecutor.execute(new Runnable() {
            @Override
            public void run(){
                System.out.println("创建对象");
                try {
                    // 创建对象（10M）
                    MyTask myTask = new MyTask();
                    // 存储 ThreadLocal
                    taskThreadLocal.set(myTask);
                    // 其他业务代码...
                } finally {
                    // 释放内存
                    taskThreadLocal.remove();
                }
            }
        });
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.

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

ThreadLocal内存溢出演示和原因分析！-鸿蒙开发者社区

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

remove的秘密

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

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

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

小结

本文我们使用代码的方式演示了 ThreadLocal 内存溢出的问题，严格来讲内存溢出并不是 ThreadLocal 的问题，而是因为没有正确使用 ThreadLocal 所带来的问题。想要避免 ThreadLocal 内存溢出的问题，只需要在使用完 ThreadLocal 后调用 remove 方法即可。

文章转载自公众号：Java中文社群

分类

其他

标签

java

已于2023-11-17 11:18:38修改

51CTO

51CTO博客

51CTO学堂

ThreadLocal内存溢出演示和原因分析！

前言

什么是内存溢出？

内存溢出代码演示

原因分析

解决方案

remove的秘密

小结

目录

订阅鸿蒙技术特刊，精选内容抢先看