threadlocal使用场景及注意事项_面试官：ThreadLocal的应用场景和注意事项有哪些？...

最新推荐文章于 2024-04-19 22:50:36 发布
最新推荐文章于 2024-04-19 22:50:36 发布
阅读量341 收藏 1
点赞数
文章标签： threadlocal使用场景及注意事项
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_29357243/article/details/113322319
版权
db04d243151abc0269ac04ebcf7c7881.png

前言

ThreadLocal主要有如下2个作用(在之前文章的基础上加了新内容)

  1. 保证线程安全

  2. 在线程级别传递变量

保证线程安全

最近一个小伙伴把项目中封装的日期工具类用在多线程环境下居然出了问题，来看看怎么回事吧

日期转换的一个工具类

public class DateUtil {

    private static final SimpleDateFormat sdf = 
            new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static Date parse(String dateStr) {
        Date date = null;
        try {
            date = sdf.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

然后将这个工具类用在多线程环境下

public static void main(String[] args) {

    ExecutorService service = Executors.newFixedThreadPool(20);

    for (int i = 0; i 20; i++) {
        service.execute(()->{
            System.out.println(DateUtil.parse("2019-06-01 16:34:30"));
        });
    }
    service.shutdown();
}

结果报异常了，因为部分线程获取的时间不对

014e83e50549544c7d67e424928dfe4e.png

这个异常就不从源码的角度分析了，写一个小Demo，理解了这个小Demo，就理解了原因

一个将数字加10的工具类

public class NumUtil {

    public static int addNum = 0;

    public static int add10(int num) {
        addNum = num;
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return addNum + 10;
    }
}
public static void main(String[] args) {

    ExecutorService service = Executors.newFixedThreadPool(20);

    for (int i = 0; i 20; i++) {
        int num = i;
        service.execute(()->{
            System.out.println(num + " " +  NumUtil.add10(num));
        });
    }
    service.shutdown();
}

然后代码的一部分输出为

0 28
3 28
7 28
11 28
15 28

什么鬼，不是加10么，怎么都输出了28？这主要是因为线程切换的原因，线程陆续将addNum值设置为0 ，3，7但是都没有执行完(没有执行到return addNum+10这一步)就被切换了，当其中一个线程将addNum值设置为18时，线程陆续开始执行addNum+10这一步，结果都输出了28。SimpleDateFormat的原因和这个类似，那么我们如何解决这个问题呢？

解决方案

解决方案1：每次来都new新的，空间浪费比较大

public class DateUtil {

    public static Date parse(String dateStr) {
        SimpleDateFormat sdf =
                new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = null;
        try {
            date = sdf.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

解决方案2：方法用synchronized修饰，并发上不来

public class DateUtil {

    private static final SimpleDateFormat sdf =
            new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static synchronized Date parse(String dateStr) {
        Date date = null;
        try {
            date = sdf.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

解决方案3：用jdk1.8中的日期格式类DateFormatter，DateTimeFormatter

public class DateUtil {

    private static DateTimeFormatter formatter = 
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    public static LocalDateTime parse(String dateStr) {
        return LocalDateTime.parse(dateStr, formatter);
    }
}

解决方案4：用ThreadLocal，一个线程一个SimpleDateFormat对象

public class DateUtil {

    private static ThreadLocal threadLocal = ThreadLocal.withInitial(
            ()-> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));public static Date parse(String dateStr) {
        Date date = null;try {
            date = threadLocal.get().parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }return date;
    }
}

上面的加10的工具类可以改成如下形式(主要为了演示ThreadLocal的使用)

public class NumUtil {

    private static ThreadLocal addNumThreadLocal = new ThreadLocal<>();public static int add10(int num) {
        addNumThreadLocal.set(num);try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }return addNumThreadLocal.get() + 10;
    }
}

现在2个工具类都能正常使用了，这是为啥呢？

原理分析

当多个线程同时读写同一共享变量时存在并发问题，如果不共享不就没有并发问题了，一个线程存一个自己的变量，类比原来好几个人玩同一个球，现在一个人一个球，就没有问题了，如何把变量存在线程上呢？其实Thread类内部已经有一个Map容器用来存变量了。它的大概结构如下所示

4a9b922c49f01b3bd29ad6845736d745.png

ThreadLocalMap是一个Map，key是ThreadLocal，value是Object

映射到源码就是如下所示：
ThreadLocalMap是ThreadLocal的一个静态内部类

public class Thread implements Runnable {
    ThreadLocal.ThreadLocalMap threadLocals = null;
}

往ThreadLocalMap里面放值

// ThreadLocal类里面的方法，将源码整合了一下
public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = t.threadLocals;
    if (map != null)
        map.set(this, value);
    else
        t.threadLocals = new ThreadLocalMap(this, firstValue);
}

从ThreadLocalMap里面取值

// ThreadLocal类里面的方法，将源码整合了一下
public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = t.threadLocals；
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

从ThreadLocalMap里面删除值

// ThreadLocal类里面的方法，将源码整合了一下
public void remove() {
    ThreadLocalMap m = Thread.currentThread().threadLocals;
    if (m != null)
        m.remove(this);
}

执行如下代码

public class InfoUtil {

    private static ThreadLocal nameInfo = new ThreadLocal<>();private static ThreadLocal ageInfo = new ThreadLocal<>();public static void setInfo(String name, Integer age) {
        nameInfo.set(name);
        ageInfo.set(age);
    }public static String getName() {return nameInfo.get();
    }public static void main(String[] args) {new Thread(() -> {
            InfoUtil.setInfo("张三", 10);// 张三
            System.out.println(InfoUtil.getName());
        }, "thread1").start();new Thread(() -> {
            InfoUtil.setInfo("李四", 20);// 李四
            System.out.println(InfoUtil.getName());
        }, "thread2").start();
    }
}

变量的结构如下图

b9223a1f74fdafb0e69f7f5c67dcae19.png

在线程级别传递变量

假设有如下一个场景，method1()调用method2()，method2()调用method3()，method3()调用method4()，method1()生成了一个变量想在method4()中使用，有如下2种解决办法

  1. method 2 3 4的参数列表上都写上method4想要的变量

  2. method 1 往ThreadLocal中put一个值，method4从ThreadLocal中get出来

哪种实现方式比较优雅呢？相信我不说你也能明白了

我在生产环境中一般是这样用的，如果一个请求在系统中的处理流程比较长，可以对请求的日志打一个相同的前缀，这样比较方便处理问题

这个前缀的生成和移除可以配置在拦截器中，切面中，当然也可以在一个方法的前后

public class Main {

    public static final ThreadLocal SPANID =
            ThreadLocal.withInitial(() -> UUID.randomUUID().toString());public static void start() {
        SPANID.set(UUID.randomUUID().toString());// 方法调用过程中可以在日志中打印SPANID表明一个请求的执行链路
        SPANID.remove();
    }
}

当然Spring Cloud已经有现成的链路追踪组件了。

ThreadLocal使用注意事项

ThreadLocal如果使用不当会造成如下问题

  1. 脏数据

  2. 内存泄露

脏数据

线程复用会造成脏数据。由于线程池会复用Thread对象，因此Thread类的成员变量threadLocals也会被复用。如果在线程的run()方法中不显示调用remove()清理与线程相关的ThreadLocal信息，并且下一个线程不调用set()设置初始值，就可能get()到上个线程设置的值

内存泄露 

static class ThreadLocalMap {

    static class Entry extends WeakReference<ThreadLocal>> {
        Object value;

        Entry(ThreadLocal> k, Object v) {
            super(k);
            value = v;
        }
    }
}

ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal没有外部强引用来引用它，那么系统 GC 的时候，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value，如果当前线程再迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永远无法回收，造成内存泄漏

大白话一点，ThreadLocalMap的key是弱引用，GC时会被回收掉，那么就有可能存在ThreadLocalMap的情况，这个Object就是泄露的对象

其实，ThreadLocalMap的设计中已经考虑到这种情况，也加上了一些防护措施：在ThreadLocal的get()，set()，remove()的时候都会清除线程ThreadLocalMap里所有key为null的value

解决办法

解决以上两个问题的办法很简单，就是在每次用完ThreadLocal后，及时调用remove()方法清理即可

eb0a344f3c297b999c56fd8fbaf10a98.png
从夏
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ThreadLocal的使用场景以及使用时要注意的问题
weixin_39599307的博客
05-20 1481
ThreadLocal的使用场景以及使用时要注意的问题 ThreadLocal的定义 ThreadLocal很容易让人望文生义，想当然地认为是一个“本地线程”。其实，ThreadLocal并不是一个Thread，而是Thread的局部变量，每个线程只能访问和修改自己的局部变量，变量彼此之间是相互隔离的，各个线程之间的变量互不干扰，在高并发场景下，可以实现无状态的调用，特别适用于各个线程依赖不通的变量值完成操作的场景。 ThreadLocal的使用 创建、设值、取值、删除 ThreadLocal<S
深入理解Java：SimpleDateFormat安全的时间格式化
weixin_33843947的博客
05-31 1762
　　想必大家对SimpleDateFormat并不陌生。SimpleDateFormat 是 Java 中一个非常常用的类，该类用来对日期字符串进行解析和格式化输出，但如果使用不小心会导致非常微妙和难以调试的问题，因为 DateFormat 和 SimpleDateFormat 类不都是线程安全的，在多线程环境下调用 format() 和 parse() 方法应该使用同步代码来避免问题。下面我们通...
ThreadLocal原理及使用场景
最新发布
weixin_54951878的博客
04-19 652
ThreadLocal
【并发编程学习篇】导致JVM内存泄露的ThreadLocal详解
热门推荐
一个勤勤恳恳的程序猿
07-23 1万+
ThreadLocal对于每一位Java读者而言我想可能都不陌生，因为面试基本都会被问到。 ThreadLocal包含了四个方法: void set(Object value) 设置当前线程的线程局部变量的值。 public Object get() 该方法返回当前线程所对应的线程局部变量。 public void remove() 将当前线程局部变量的值删除，其目的是为了减少内存使用，加快内存回收。 protected Object initialValue() 返回该线程局部变量的初始值，.
ThreadLocal的常用场景
qq_46130027的博客
04-17 1212
当用户登录后，会将用户信息存入Token中返回前端，当用户调用需要授权的接口时，需要在header中携带Token，然后拦载器中解析Token，获取用户信息，调用自定义的类存ThreadLocal中，当请求结束的时候，将ThreadLocal存储数据清空，中间的过程无需在关注如何获取用户信息，只需要使用工具类的get方法即可。中使用，当web请求进来的时候，我们就可以将一些数据放入到threadLocal中，这样后续所有的相关业务，都可以直接拿到这个值。
京东一面：说出ThreadLocal的使用场景及使用方式.zip
12-13
计算机技术、IT咨询、人工智能AI理论介绍，学习参考资料 计算机技术、IT咨询、人工智能AI理论介绍，学习参考资料 计算机技术、IT咨询、人工智能AI理论介绍，学习参考资料 计算机技术、IT咨询、人工智能AI理论介绍，...
Java源码解析ThreadLocal及使用场景
08-26
今天小编就为大家分享一篇关于Java源码解析ThreadLocal及使用场景，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
ThreadLocal的原理是什么，使用场景有哪些.md
09-26
ThreadLocal的原理是什么，使用场景有哪些.md
Java 高并发九：锁的优化和注意事项详解
09-01
本文主要介绍Java高并发锁的优化和注意事项，这里整理了详细的资料，并讲解了 1. 锁优化的思路和方法 2. 虚拟机内的锁优化 3. 一个错误使用锁的案例 4. ThreadLocal及其源码分析等知识，有需要的小伙伴可以参考下
ThreadLocal.pdf
04-13
ThreadLocal
ThreadLocal_ThreadLocal源码分析_源码.zip
10-18
ThreadLocal_ThreadLocal源码分析_源码.zip
Python 兵法编程 265_ThreadLocal的使用.mp4
02-09
Python 兵法编程 265_ThreadLocal的使用.mp4
ThreadLocal 线程本地变量 及 源码分析.rar_开发_设计
09-20
ThreadLocal 线程微本地变量 及 源码分析
ThreadLocal详解.md
10-31
学习ThreadLocal，了解其中的原理，以及学习其中的优点！避免坑点！！
ThreadLocal的原理，源码深度分析及使用.docx
09-15
ThreadLocal的原理，源码深度分析及使用.docx，这是一份ThreadLocal的技术文档
ThreadLocal使用场景
weixin_35750747的博客
02-15 1080
ThreadLocal 是 Java 中的一个类，它可以让我们在多线程环境下实现线程安全的数据共享，其作用是为每个线程提供独立的变量副本，每个线程都可以访问自己所拥有的变量副本，从而避免了线程安全问题。 以下是一些 ThreadLocal 使用场景： 线程池中的线程对象共享数据：线程池中的线程对象是可以被多个任务共享的，如果线程对象中需要保存任务相关的数据，使用 ThreadLocal 可以保证...
ThreadLocal常用方法浅析、使用场景及注意事项
qq_42742861的博客
05-29 3312
1. ThreadLocal详解 JDK1.2版本起，Java就提供了java.lang.ThreadLocal，ThreadLocal为每个使用线程都提供独立的变量副本，可以做到线程间的数据隔离，每个线程都可以访问各自内部的副本变量。 线程上下文ThreadLocal又称为"线程保险箱"，ThreadLocal能够将指定的变量和当前线程进行绑定，线程之间彼此隔离，持有不同的对象实例，从而避免了数...
ThreadLocal的介绍+经典应用场景
12-23 2407
????作者小三是刚刚毕业不久全栈工程师，写的技术文章基本上是学习过程中笔记整理而来，大家看了之后如果喜欢可以给小弟点点赞哦。????例外小弟还有个程序员交流群，欢迎各位大佬来摸鱼哈。点击加群 什么是ThreadLocal ThreadLocal又叫做线程局部变量，全称thread local variable，它的使用场合主要是为了解决多线程中因为数据并发产生不一致的问题。ThreadLocal为每一个线程都提供了变量的副本，使得每一个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的
弱引用什么时候被回收_面试官：ThreadLocal为什么会发生内存泄漏？
06-08
弱引用在垃圾回收时会被回收，即使该对象有弱引用指向它，只要...为了避免这种情况，我们需要在使用完ThreadLocal之后及时将其从ThreadLocalMap中移除，可以通过调用remove方法或者使用Java8中的弱引用来解决这个问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值