ThreadLocal

最新推荐文章于 2024-11-04 22:26:34 发布
最新推荐文章于 2024-11-04 22:26:34 发布
阅读量122 收藏
点赞数
分类专栏： 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ilikeu777/article/details/117364926
版权

多线程 java 内存泄漏

线程解决方案

1、 加锁

加锁⽅案虽然可以正确的解决线程不安全的问题，但同时也引⼊了新的问题，加锁会让程序进⼊排 队执⾏的流程，从⽽⼀定程度的降低了程序的执⾏效率，那有没有⼀种⽅案既能解决线程不安全的 问题，同时还可以避免排队执⾏呢？

2、ThreadLocal(ThreadLocal 线程本地变量 ：线程级别的私有变量，与任务级别的私有变量完全不同)

ThreadLocal经典实用场景：

1、解决线程安全问题
2、实现线程级别的数据传递

ThreadLocal使用

1、set（T）：将私有变量存放到线程中
2、get（）：从线程中取得私有变量
3、remove（）：从线程中移除私有变量（如果不进行remove操作，会造成脏读、内存溢出）
4、initialValue：初始化方法1
5、withInitial:初始化方法2

ThreadLocal 基础⽤法如下：

public class ThreadPoolLocal1 {
    static ThreadLocal<String> threadLocal = new ThreadLocal<>();
    public static void main(String[] args) {

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //set
                String tname = Thread.currentThread().getName();
                threadLocal.set(tname);
                System.out.println(String.format("线程：%s 设置了值：%s",tname,tname));
                printTname();
            }
        },"线程1");
        t1.start();


        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //set
                String tname = Thread.currentThread().getName();
                threadLocal.set(tname);
                System.out.println(String.format("线程：%s 设置了值：%s",tname,tname));
                printTname();
            }
        },"线程2");
        t2.start();
    }

    private static void printTname() {
        String tname = Thread.currentThread().getName();
        //得到存放在ThreadLocal中的值

    }
}

在这里插入图片描述

initialValue的用法

public class ThreadPoolLocal2 {
    private static ThreadLocal<String> threadLocal = new ThreadLocal(){
        @Override
        protected String initialValue() {
            System.out.println("执行了initialValue方法");
            return "默认值";
        }
    };

    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                String threadName = Thread.currentThread().getName();
                print(threadName);
            }
        };
        new Thread(runnable,"t1").start();
        new Thread(runnable,"t2").start();
    }
    //打印threadLocal中的值
    private static void print (String threadName){
        String result = threadLocal.get();
        System.out.println("线程：" + threadName + "得到值：" + result);
    }
}

在这里插入图片描述

initialValue + get
正常存取现象
initialValue + set + get？
先执行set方法，在执行get方法

什么情况下不会执行InitialValue？为什么不会？
答：set之后就不会执行了
ThreadLocal是懒加载，当调用了get方法之后，才会尝试执行InitialValue（初始化）方法，尝试获取一下ThreadLocal set的值，如果获取到了值，那么初始化方法永远不会执行。

注意在使⽤ initialValue 时，返回值的类型要和 ThreadLoca 定义的数据类型保持⼀致。
在这里插入图片描述

如果数据不⼀致就会造成 ClassCaseException 类型转换异常，如下图所示：
在这里插入图片描述

withInitial的用法

import java.util.function.Supplier;

public class ThreadPoolLocal3 {
    private static ThreadLocal<String> threadLocal =
            ThreadLocal.withInitial(new Supplier<String>() {
                @Override
                public String get() {
                    System.out.println("执行了初始化方法");
                    return "默认值";
                }
            });

    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                String threadName = Thread.currentThread().getName();
                print(threadName);
            }
        };
        new Thread(runnable,"t1").start();
        new Thread(runnable,"t2").start();
    }
    //打印threadLocal中的值
    private static void print (String threadName){
        String result = threadLocal.get();
        System.out.println("线程：" + threadName + "得到值：" + result);
    }
}

在这里插入图片描述
好像跟initialValue没什么区别？
别急！withInitial还有一种很简洁的方法。

public class ThreadPoolLocal3 {
    private static ThreadLocal<String> threadLocal =
            ThreadLocal.withInitial(()->"默认值");

    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                String threadName = Thread.currentThread().getName();
                print(threadName);
            }
        };
        new Thread(runnable,"t1").start();
        new Thread(runnable,"t2").start();
    }
    //打印threadLocal中的值
    private static void print (String threadName){
        String result = threadLocal.get();
        System.out.println("线程：" + threadName + "得到值：" + result);
    }
}

在这里插入图片描述
是不是更方便了呢？

ThreadLocal的缺点

1、不可继承性

子线程中不可读取到父线程的值。

public class ThreadPoolLocal9 {
    private static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        String data = "java";
        System.out.println("主线程存入数据:" + data);
        threadLocal.set(data);
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                String result = threadLocal.get();
                System.out.println("子线程读取数据："+result);
            }
        });
        t1.start();
    }

}

在这里插入图片描述
如何解决不可继承性？
InheritableThreadLocal

public class ThreadPoolLocal9 {
    private static ThreadLocal<String> threadLocal = new InheritableThreadLocal<>();

    public static void main(String[] args) {
        String data = "java";
        System.out.println("主线程存入数据:" + data);
        threadLocal.set(data);
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                String result = threadLocal.get();
                System.out.println("子线程读取数据："+result);
            }
        });
        t1.start();
    }

}

在这里插入图片描述

不能实现不同线程之间的数据共享。

public class ThreadPoolLocal9 {
    private static ThreadLocal<String> threadLocal = new InheritableThreadLocal<>();

    public static void main(String[] args) throws InterruptedException {


        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                String data = "java";
                threadLocal.set(data);
                String result = threadLocal.get();
                System.out.println("t1存入数据："+ result);
            }
        });
        t1.start();
        t1.join();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                String result = threadLocal.get();
                System.out.println("t2线程得到数据：" + result);
            }
        });
        t2.start();
    }

}

在这里插入图片描述
为什么会出现这种情况？
因为⽆论是 ThreadLocal 还是 InheritableThreadLocal 本质都是线程本地变 量，所以不能跨线程进⾏数据共享也是正常的。

2、脏数据

在一个线程中读取到了不属于自己的数据。
！！！线程使用ThreadLocal不会出现脏读，因为每个线程使用的是自己的变量值和ThreadLocal。
在使⽤线程池的时候，因为线程池会复⽤线程，那么和线程绑定的静态属性也会被复⽤（如： ThreadLocal），所以如果下⼀个线程不执⾏ set 操作或者上⼀个线程不执⾏ remove 操作，那么下⼀个 线程就可以读取到旧值，如下代码所示：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolLocal10 {
    private static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        //创建线程为一个的线程池
        ExecutorService service =  Executors.newFixedThreadPool(1);
        for (int i = 0; i < 2; i++) {
            MyThread myThread = new MyThread();
            service.execute(myThread);
        }
        service.shutdown();
    }
    private static class MyThread extends Thread{
        private static boolean flag = true;

        @Override
        public void run() {
            if (flag){
                threadLocal.set(this.getName() + " session info");
                flag = false;
            }
            System.out.println(this.getName() + "：" + threadLocal.get());
        }
    }
}

在这里插入图片描述
脏数据的解决方案：
1、避免使用静态属性（静态属性在线程池中会复用）
2、使用remove解决。

3、内存溢出问题（最常出现的问题）

内存溢出：当一个线程执行完之后，不会释放线程所占用的内存或者释放内存不及时的情况都叫着内存溢出。线程不用了，单线程线程相关的内存还得不到及时的释放。

线程和线程池使用ThreadLocal的的区别：产生OOM异常
原因：ThreadLocal + 线程池（线程池是长生命周期的），而线程是执行完任务线程就结束了（线程相关的资源都会释放掉）。

为什么会发生OOM？
ThreadPool（长生命周期）-》Thread-》ThreadLocalMap-》Entry[]-》Entry-》key（弱引用），value（强引用）
为什么将ThreadLocal中的key设置成弱引用？
答：为了最大程度的避免OOM。
如何解决ThreadLocal的溢出？
使用remove（）。
这里先演示一下：
将线程最大内存改为5m
在这里插入图片描述

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

public class ThreadLocal2 {
    static class OOMObject{
        //1m大小的对象
        private byte[] bytes = new byte[1*1024*1024];
    }
    static ThreadLocal<OOMObject> threadLocal = new ThreadLocal<>();
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10,10,0, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>());
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    OOMObject oomObject = new OOMObject();
                    //set threadlocal
                    System.out.println("任务：" + finalI + "执行了");
                    threadLocal.set(oomObject);
                    //不用对象了
                    oomObject = null;
                }
            });

            Thread.sleep(200);
        }
    }
}

在这里插入图片描述
这里可以看到，当执行了三个任务之后，就发生了OOM异常，因为主线程也占用了一定内存，所以它根本不可能执行完五个任务。
我们再来看看使用remove方法之后的结果：

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

public class ThreadLocal3 {
    static class OOMObject{
        //1m大小的对象
        private byte[] bytes = new byte[1*1024*1024];
    }
    static ThreadLocal<OOMObject> threadLocal = new ThreadLocal<>();
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10,10,0, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>());
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        OOMObject oomObject = new OOMObject();
                        //set threadlocal
                        System.out.println("任务：" + finalI + "执行了");
                        threadLocal.set(oomObject);
                        //不用对象了
                        oomObject = null;
                    }finally {
                        threadLocal.remove();
                    }
                }
            });

            Thread.sleep(200);
        }
    }
}

在这里插入图片描述
可以看到五个任务都执行完了。

HashMap和ThreadLocalMap处理hash冲突的区别：
HashMap使用的链式法，ThreadLocalMap使用的开放寻址法
为什么要这么实现？

答：开放寻址法的特点是：数据量比较少的情况下，性能更好；
而HashMap存储的数据通茶情况下是比较多的，使用开放寻址法效率就比较低了，这个时候最好使用链式法。

升级：链表-》红黑树
1、链表长度大于8
2、数组的长度大于64

降级：红黑树-》链表
1、当链表的长度小于6

宋丹尼尔
关注
专栏目录
threadLocal
03-20
ThreadLocal是Java编程语言中的一个线程局部变量类，它为每个线程提供了一个独立的变量副本，使得每个线程可以独立地改变自己的副本，而不会影响其他线程所对应的副本。这个特性在多线程环境下处理并发问题时非常...
ThreadLocal的用法小例子：
有才而性缓，定属大才。有智而气和，斯为大智。
04-05 559
主要是共享工具类的使用，如果是一种竞争改变共享属性对象的话，还是需要同步代码块，锁机制 1.共享时间类转换 public class DateUtil { private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); publi...
谈谈Java中的StringBuilder与StringBuffer
m0_68642284的博客
03-20 1132
详解Java中的StringBuilder与StringBuffer
[项目实战笔记]-使用ThreadLocal请务必remove
Sean Zou
08-20 1万+
场景说明:压测的时候发现调用某个接口同一个入参，返回的商品数据不一致。 使用技术：threadLocal 问题原因：使用ThreadLocal没有remove。 导致问题：1内存溢出，ThreadLocal依赖没有释放，无法GC。 2线程池的某个线程会被反复使用,ThreadLocal的生命周期不等于一次Request的生命周期，造成获取threadL...
ThreadLocal相关知识
weixin_51392818的博客
06-02 164
ThreadLocal 经典使用场景： 1.解决线程不安全的问题 2.线程级的数据传递（可以实现一定程度的解耦） ThreadLocal缺陷： 1.不可继承性（子线程不能继承主线程的私有变量） 2.脏数据（一个程序的任务执行当中，读取了其他任务的数据） 3.内存溢出 如何避免脏数据： 1.避免使用静态变量 2.使用完之后，进行remove操作 内存溢出：当一个线程使用完资源之后，没有释放资源，或者说释放资源不及时就会造成内存溢出。 内存溢出的原因： 1.因为线程池是长生命周期的 2.Threa
Java8-ThreadLocal的Lambda构造方式：withInitial
Zebe
09-14 2万+
ThreadLocal的Lambda构造方式 Java8中ThreadLocal对象提供了一个Lambda构造方式，实现了非常简洁的构造方法：withInitial。这个方法采用Lambda方式传入实现了 Supplier 函数接口的参数。写法如下： 代码实例 /** * 当前余额 */ private ThreadLocal&amp;amp;lt;Integer&amp;amp;gt; balance = T...
ThreadLocal 内存泄露的实例分析1
08-04
在 `LeakingServlet` 的 `doGet` 方法中，如果 `ThreadLocal` 没有设置值，那么会创建一个新的 `MyCounter` 并设置到 `ThreadLocal` 中。关键在于，一旦 `MyCounter` 被设置到 `ThreadLocal`，那么它将与当前线程...
ant Design中Select设置initialValue时的大坑
smile_68的博客
02-20 1万+
我出现的问题：例如在编辑活动关联红包的时候，需求是select显示的是红包名称，但是表单提交的时候是红包ID：设置默认值的initialValue为Id的时候，会出现显示是id (需要的是显示名称)；如果设置默认值initialValue是名称，那么下一步操作会出现报错 但是我还有一种情况：某个活动关联的红包被删除了，在Select中的可供选项中redPackets没有这个红包的时候，显示的会是红...
对ThreadLocal的深入理解
unstoppable_t的博客
05-26 803
ThreadLocal一级目录ThreadLocal是什么ThreadLocal使用三级目录 一级目录 ThreadLocal是什么 讲ThreadLocal之前，我们先回顾一下线程不安全的解决方案： 1.给对象加锁（synchronized加锁或Lock加锁） 2.让线程拥有私有变量，不让多个线程修改一个变量 对于2这种方式而言，但是设置私有变量的方法有一个缺陷，当任务数量比较多时，每一次任务执行都会创建私有变量，这会导致大量占用内存，浪费空间。 因而Java中有一种比较高效的解决线程安全的方案：Th
深入学习java源码之ThreadLocal.get()()与ThreadLocal.initialValue()
悦分享
01-20 2万+
深入学习java源码之ThreadLocal.get()()与 ThreadLocal.initialValue() 并发编程ThreadLocal 线程封闭机制强调局部的概念，就是在写代码的时候，尽量使用局部变量代替全局变量（这种叫做栈封闭），如果一定要使用全局变量，而又想让多个线程之间在访问共享变量的时候互不影响，那就使用ThreadLocal&lt;T&gt;。ThreadLocal&l...
深挖ThreadLocal
热门推荐
逆风奔跑。。不要去考虑什么天赋异禀，一切都来自经历和渴望。
04-22 42万+
ThreadLocal是什么 早在JDK 1.2的版本中就提供java.lang.ThreadLocal，ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序。 ThreadLocal很容易让人望文生义，想当然地认为是一个“本地线程”。其实，ThreadLocal并不是一个Thread，而是Thread的局部变量，也许把它
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 492
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 988
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
qq_36400213的博客
11-04 565
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 349
默认对常规Session的理解和使用，如何使用Set-Cookie。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 197
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
threadlocal
11-09
ThreadLocal通常用于解决多线程并发访问时的数据安全问题，它可以保证每个线程中的变量都是独立的，不会相互影响。在Java中，ThreadLocal类提供了get()和set()方法来获取和设置线程的本地变量值，remove()方法用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

宋丹尼尔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值