研二学妹面试字节,竟倒在了ThreadLocal上,这是不要应届生还是不要女生啊?

threadlocal · 浏览次数 : 0

小编点评

**ThreadLocal 问题解决方法** 1. **清理资源:** 在使用完 ThreadLocal 中存储的内容后,务必调用 `remove()` 方法将其从 `ThreadLocalMap` 中移除。 2. **InheritableThreadLocal:** 使用 `InheritableThreadLocal` 可以解决内存泄漏问题,因为它会在子线程中自动继承父线程的线程局部变量值。 3. **线程间局部变量传值:** 在子线程中获取父线程的 `inheritableThreadLocals` 值时,需要从 `ThreadLocalMap` 中获取并调用 `childValue()` 方法。 4. **ThreadLocal 的创建:** `InheritableThreadLocal` 在创建新的线程时会根据父线程的 `ThreadLocalMap` 创建一个子线程的 `ThreadLocalMap`,并将其赋值给子线程。 5. **`ThreadLocalMap` 的构建:** `ThreadLocalMap` 在创建子线程的 `ThreadLocal` 时会根据父线程的 `ThreadLocalMap` 创建一个新 `ThreadLocalMap`。 6. **清理资源:** 在子线程中释放 `ThreadLocal` 的资源,以便释放父线程的资源。 7. **使用 `InheritableThreadLocal`:** 使用 `InheritableThreadLocal` 可以解决内存泄漏问题,并简化线程间局部变量传值过程。

正文

一、写在开头

    今天和一个之前研二的学妹聊天,聊及她上周面试字节的情况,着实感受到了Java后端现在找工作的压力啊,记得在18,19年的时候,研究生计算机专业的学生,背背八股文找个Java开发工作毫无问题,但现在即便你是应届生,问的考题也非常的深入和细节了,只会背八股,没有一定的代码量和项目积累,根本找不到像样的工作,具体聊天内容如下:

image

既然大厂的面试都拷问到ThreadLocal了,那今天build哥就花点时间也来温习一下这个知识点吧,尽可能整理的细致一点!🤓🤓

二、ThreadLocal简介

2.1 ThreadLocal的作用

处理并发编程的时候,其核心问题是当多个线程去访问共享变量时,因为顺序、资源分配等原因带来了数据的不准确,我们叫这种情况为线程不安全,为了解决线程安全问题,在Java中可以采用Lock、 synchronzed关键字等方式,但这种方式对于没有持有锁的线程来说会阻塞,这样以来在时间性能上就有所损失。

为了解决这个问题,Java的lang包中诞生出了一个类,名为 ThreadLocal,见名知意,它被视为线程的“本地变量”,主要用来存储各线程的私有数据,当多个线程访问同一个ThreadLocal变量时,实际上它们访问的是各自线程本地存储的副本,而不是共享变量本身。因此,每个线程都可以独立地修改自己的副本,而不会影响到其他线程。这种以空间换时间的方式,可以大大的提升处理时间。

2.2 ThreadLocal的使用案例

上面了解了它的特性后,我们来写一个小demo感受一下ThreadLocal的使用。

public class TestService implements Runnable{
        // SimpleDateFormat 不是线程安全的,所以每个线程都要有自己独立的副本
        //共享变量
        private static final ThreadLocal<SimpleDateFormat> formatter = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyyMMdd"));

        public static void main(String[] args) throws InterruptedException {
            TestService obj = new TestService();
            //循环创建5个线程
            for(int i=0 ; i<5; i++){
                Thread t = new Thread(obj, ""+i);
                Thread.sleep(new Random().nextInt(1000));
                t.start();
            }
        }

        @Override
        public void run() {
            System.out.println("Thread:"+Thread.currentThread().getName()+" default Formatter = "+formatter.get().toPattern());
            try {
                Thread.sleep(new Random().nextInt(1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //formatter pattern is changed here by thread, but it won't reflect to other threads
            //设置副本的值
            formatter.set(new SimpleDateFormat());
            System.out.println("Thread:"+Thread.currentThread().getName()+" formatter = "+formatter.get().toPattern());
        }
}

输出:

Thread:0 default Formatter = yyyyMMdd
Thread:1 default Formatter = yyyyMMdd
Thread:2 default Formatter = yyyyMMdd
Thread:1 formatter = yy-M-d ah:mm
Thread:0 formatter = yy-M-d ah:mm
Thread:3 default Formatter = yyyyMMdd
Thread:2 formatter = yy-M-d ah:mm
Thread:3 formatter = yy-M-d ah:mm
Thread:4 default Formatter = yyyyMMdd
Thread:4 formatter = yy-M-d ah:mm

从输出中可以看出,虽然 Thread-0 已经改变了 formatter 的值,但 Thread-1 默认格式化值与初始化值相同并没有被修改,其他线程也一样,这说明每个线程获取ThreadLocal变量值的时候,确访问的时线程本地的副本值。

三、ThreadLocal的实现原理

我们从Thread源码入手,一步步的跟进,去探索ThreadLocal的实现原理。首先,在Thread的源码中,我们看到了这样的两句定义语句:

public class Thread implements Runnable {
    //......
    //与此线程有关的ThreadLocal值。由ThreadLocal类维护
    ThreadLocal.ThreadLocalMap threadLocals = null;

    //与此线程有关的InheritableThreadLocal值。由InheritableThreadLocal类维护
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
    //......
}

threadLocals 、inheritableThreadLocals 都是ThreadLocalMap变量,而这个Map我们可以看作是ThreadLocal的定制化HashMap,用来存储线程本地变量的容器,是一个静态内部类,而这两个变量的值初始为null,只有当前线程调用 ThreadLocal 类的 set或get方法时才创建它们,那我们继续去看set/get方法。

【set方法解析】

public void set(T value) {
	//1. 获取当前线程实例对象
    Thread t = Thread.currentThread();

	//2. 通过当前线程实例获取到ThreadLocalMap对象
    ThreadLocalMap map = getMap(t);

    if (map != null)
	   //3. 如果Map不为null,则以当前ThreadLocal实例为key,值为value进行存入
       map.set(this, value);
    else
	  //4.map为null,则新建ThreadLocalMap并存入value
      createMap(t, value);
}

在ThreadLocal的set方法中通过getMap()方法去获取当前线程的ThreadLocalMap对象,并对获取到的map进行判断,我们跟如到getMap方法中去,发现其实里面返回的是初始化定义的threadLocals变量。

ThreadLocalMap getMap(Thread t) {
   return t.threadLocals;
}

在threadLocals没有被调用初始化方法重新赋值的时候,它为null(不为null时,直接set进行赋值,当前ThreadLocal实例为key,值为value),set方法中会去调用createMap(t,value)进行处理,我们继续跟入这个方法的源码去看看:

void createMap(Thread t, T firstValue) {
  t.threadLocals = new ThreadLocalMap(this, firstValue);
}

我们可以看到,在这个方法内部,会去新构造一个ThreadLocalMap的实例,并将value值初始化进去,并赋给threadLocals。

看完了set方法的底层实现我们知道:

  1. 最终变量存储的位置在ThreadLocalMap里,ThreadLocal可以视为这个Map的封装;
  2. 无论如何最终threadLocals存储的数据都是以线程为key,对应的局部变量为值得映射表;
  3. 因为映射表的原因,确保了每个线程的局部变量都时独立的。

【get方法解析】

看完了set的源码,我们继续来看看get方法的底层实现吧,既然有存(set)就有取(get),get 方法提供的就是获取当前线程中 ThreadLocal 的变量值的功能!

public T get() {
  //1. 获取当前线程的实例对象
  Thread t = Thread.currentThread();

  //2. 获取当前线程的ThreadLocalMap
  ThreadLocalMap map = getMap(t);
  if (map != null) {
	//3. 获取map中当前ThreadLocal实例为key的值的entry
    ThreadLocalMap.Entry e = map.getEntry(this);

    if (e != null) {
      @SuppressWarnings("unchecked")
	  //4. 当前entitiy不为null的话,就返回相应的值value
      T result = (T)e.value;
      return result;
    }
  }
  //5. 若map为null或者entry为null的话通过该方法初始化,并返回该方法返回的value
  return setInitialValue();
}

我们上面提到了线程的变量值是和线程的ThreadLocal有映射关系的,所以这里将当前线程的ThreadLocal作为key去map中获取值,若map为null或者entry为null的话通过该方法初始化,并返回该方法返回的value,我们去看看setInitialValue的实现:

private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}
protected T initialValue() {
    return null;
}

这个方法里的实现和set几乎一模一样,这里调用了一个protected访问修饰符的方法initialValue(),这个方法可以被子类重写。

我们在2.2使用案例中写道的ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyyMMdd"));这是在Java8中的写法,等价于:

private static final ThreadLocal<SimpleDateFormat> formatter = new ThreadLocal<SimpleDateFormat>(){
    @Override
    protected SimpleDateFormat initialValue(){
        return new SimpleDateFormat("yyyyMMdd");
    }
};

setInitialValue 方法的目的是确保每个线程在第一次尝试访问其 ThreadLocal 变量时都有一个合适的值。

3.1 ThreadLocalMap

上面我们也说了,ThreadLocalMap是ThreadLocal的静态内部类,而每个线程独立的变量副本存储也是在这个Map中,它是一个定制的哈希表,底层维护了一个Entry 类型的数组类型的数组 table,它的内部提供了set、remove、getEntry等方法。

Entry静态内部类
这个Entry又是ThreadLocalMap的一个静态内部类,我们看一下它的源码:

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

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

Entry 继承了弱引用 WeakReference<ThreadLocal<?>>,它的 value 字段用于存储与特定 ThreadLocal 对象关联的值,key 为弱引用,意味着当 ThreadLocal 外部强引用被置为 null(ThreadLocalInstance=null)时,根据可达性分析,ThreadLocal 实例此时没有任何一条链路引用它,所以系统 GC 的时候 ThreadLocal 会被回收。这种操作看似利用垃圾回收器节省了内存空间,实则存在一个风险,也就是我们下面要说的内存泄露问题!

只具有弱引用的对象,拥有更为短暂的生命周期,在GC线程扫描到它所在的内存区域的时候,一旦发现了只有弱引用的对象的时候,不管内存够不够用都会将其回收掉

四、ThreadLocal内存泄漏问题

4.1 内存泄漏的原因

如果非要问ThreadLocal有什么缺点的话,那就是使用不当的时候,会带来内存泄漏问题。

内存泄漏 是指程序中已动态分配的堆内存由于某种原因程序未释放或无法释放,造成系统内存的浪费,导致程序运行速度减慢甚至系统崩溃等严重后果。

根据3.1中的分析,我们知道ThreadLocalMap中的使用的key是ThreadLocal的弱引用,Value为强引用,如果ThreadLocal没有被强引用的话,key会被GC掉,而value依旧存在,若我们采用任何措施的前提下,线程一直运行,那这些value值就会一直存在,过多的占用内存,导致内存泄漏!

4.2 如何解决内存泄漏

如何解决内存泄漏呢,只需要记得在使用完 ThreadLocal 中存储的内容后将它 remove 掉就可以了。

//ThreadLocal提供的清理方法
public void remove() {
	//1. 获取当前线程的ThreadLocalMap
	ThreadLocalMap m = getMap(Thread.currentThread());
 	if (m != null)
		//2. 从map中删除以当前ThreadLocal实例为key的键值对
		m.remove(this);
}
/**
 * ThreadLocalMap中的remove方法
 */
private void remove(ThreadLocal<?> key) {
    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)]) {
        if (e.get() == key) {
			//将entry的key置为null
            e.clear();
			//将该entry的value也置为null
            expungeStaleEntry(i);
            return;
        }
    }
}

除此之外,我们还可以使用Java 8引入的InheritableThreadLocal来替代ThreadLocal,它可以在子线程中自动继承父线程的线程局部变量值,从而避免在创建新线程时重复设置值的问题。但是同样需要注意及时清理资源以避免内存泄漏。

五、线程间局部变量传值问题

上面我们提到的Java8中引入的InheritableThreadLocal类,这是实现父子线程间局部变量传值的关键!
InheritableThreadLocal存在于java.lang包中是ThreadLocal的扩展,它有一个特性,那就是当创建一个新的线程时,如果父线程中有一个 InheritableThreadLocal 变量,那么子线程将会继承这个变量的值。这意味着子线程可以访问其父线程为此类变量设置的值。我们写一个小demo感受一下!

public class TestService{
    // 创建一个 InheritableThreadLocal 变量
    private static final InheritableThreadLocal<String> inheritableThreadLocal = new InheritableThreadLocal<>();

    public static void main(String[] args) {
        // 在主线程中设置值
        inheritableThreadLocal.set("这是父线程的值");

        System.out.println("父线程中的值: " + inheritableThreadLocal.get());

        // 创建一个子线程
        Thread childThread = new Thread(() -> {
            // 在子线程中尝试获取值,由于使用了 InheritableThreadLocal,这里会获取到父线程中设置的值
            System.out.println("子线程中的值: " + inheritableThreadLocal.get());
        });

        // 启动子线程
        childThread.start();

        // 等待子线程执行完成
        try {
            childThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 主线程结束时清除值,防止潜在的内存泄漏
        inheritableThreadLocal.remove();
    }
}

输出:

父线程中的值: 这是父线程的值
子线程中的值: 这是父线程的值

输出不出所料,在子线程中获取的其实是父线程设置的inheritableThreadLocal值。

5.1 父子线程局部变量传值的实现原理

我们看到上面的输出后,应该思考这样的一个问题:子线程是怎么拿到父线程的inheritableThreadLocal值得呢?其实要从子线程的初始化开始说起,在线程Thread的内部,有着这样的一个初始化方法:

private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize, AccessControlContext acc,
                  // 该参数一般默认是 true
                  boolean inheritThreadLocals) {
  // 省略大部分代码
  Thread parent = currentThread();
  
  // 复制父线程的 inheritableThreadLocals 属性,实现父子线程局部变量共享
  if (inheritThreadLocals && parent.inheritableThreadLocals != null) {
       this.inheritableThreadLocals =
    ThreadLocal.createInheritedMap(parent.inheritableThreadLocals); 
  }
    // 省略部分代码
}

在这里将父线程的inheritableThreadLocals赋值了进来,我们跟入createInheritedMap方法中继续解析:

// 返回一个ThreadLocalMap,传值为父线程的
static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
  return new ThreadLocalMap(parentMap);
}
//ThreadLoaclMap构建的过程中会调用该构造方法
private ThreadLocalMap(ThreadLocalMap parentMap) {
  Entry[] parentTable = parentMap.table;
  int len = parentTable.length;
  setThreshold(len);
  table = new Entry[len];
    // 一个个复制父线程 ThreadLocalMap 中的数据
  for (int j = 0; j < len; j++) {
    Entry e = parentTable[j];
    if (e != null) {
      @SuppressWarnings("unchecked")
      ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
      if (key != null) {
        // childValue 方法调用的是 InheritableThreadLocal#childValue(T parentValue)
        Object value = key.childValue(e.value);
        Entry c = new Entry(key, value);
        int h = key.threadLocalHashCode & (len - 1);
        while (table[h] != null)
          h = nextIndex(h, len);
        table[h] = c;
        size++;
      }
    }
  }
}

在这个构造方法中,我们终于看到了InheritableThreadLocal的身影,childValue()方法就是其中的一个方法,用来给子线程赋父线程的inheritableThreadLocals值;其实InheritableThreadLocal的源码非常非常的简单,大部分的实现都取自父类ThreadLocal。

public class InheritableThreadLocal<T> extends ThreadLocal<T> {

    protected T childValue(T parentValue) {
        return parentValue;
    }

    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }
  
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

六、总结

OK,基于学妹在字节面试的考点,我们又梳理了一遍ThreadLocal,这个类大家还是要好好学一学的,毕竟在日后的工作中,我们肯定会使用到,譬如用它来保存用户登录信息,这样在同一个线程中的任何地方都可以获取到登录信息;用于保存事务上下文,这样在同一个线程中的任何地方都可以获取到事务上下文等等。

七、结尾彩蛋

如果本篇博客对您有一定的帮助,大家记得留言+点赞+收藏呀。原创不易,转载请联系Build哥!
image

如果您想与Build哥的关系更近一步,还可以关注“JavaBuild888”,在这里除了看到《Java成长计划》系列博文,还有提升工作效率的小笔记、读书心得、大厂面经、人生感悟等等,欢迎您的加入!
image

与研二学妹面试字节,竟倒在了ThreadLocal上,这是不要应届生还是不要女生啊?相似的内容:

研二学妹面试字节,竟倒在了ThreadLocal上,这是不要应届生还是不要女生啊?

一、写在开头 今天和一个之前研二的学妹聊天,聊及她上周面试字节的情况,着实感受到了Java后端现在找工作的压力啊,记得在18,19年的时候,研究生计算机专业的学生,背背八股文找个Java开发工作毫无问题,但现在即便你是应届生,问的考题也非常的深入和细节了,只会背八股,没有一定的代码量和项目积累,根本

自研WPF插件系统(沙箱运行及热插拔)

前言 插件化的需求主要源于对软件架构灵活性的追求,特别是在开发大型、复杂或需要不断更新的软件系统时,插件化可以提高软件系统的可扩展性、可定制性、隔离性、安全性、可维护性、模块化、易于升级和更新以及支持第三方开发等方面的能力,从而满足不断变化的业务需求和技术挑战。 一、插件化探索 在WPF中我们想要开

【产研测类】线上问题处理机制

1 概述 本规范致力于优化运营与产研团队在线问题管理的效率与效果,全面覆盖生产问题的识别、处理机制、分类分级、责任归属和明确奖惩机制。同时,侧重资源重点解决主流程关联的核心模块生产问题。如此,确保各个环节责任到人,内容详实,助力团队高效协同。 2 线上问题 2.1 线上问题定义 在互联网产品研发、运

风光储一体化园区 | 图扑新能源可视化

图扑利用自研产品 HT for Web 搭建风光储园区可视化监控系统,整合风力发电、光伏发电和储能系统,实现了能源的多元化生产和储备,提高了能源利用效率,增强了电网的稳定性和可靠性。在这一体系中,风电、光伏和储能各自扮演着重要的角色,并且相辅相成。

flutter3-weos手机OS系统|Flutter3.22+Getx仿ios桌面管理OA应用

原创自研flutter3.x+getx仿制ios手机桌面UI管理系统模板Flutter3-OS。 flutter3-osx基于最新跨平台技术Flutter3.22+Dart3.4+GetX+fl_chart实战仿IOS风格手机os管理系统。全新自研flutter磁贴式栅格布局引擎、分屏式多页管理、自

图扑智慧农业——生态鱼塘数字孪生监控

图扑软件应用自研 HT for Web 产品,打造轻量化智慧生态鱼塘可视化解决方案。页面整体以工业金属风格为主,采用 PBR 材质技术,精细打造鱼塘场景,实现水质透明、鱼类生动的高度逼真渲染效果。

[转帖]全部自研完成 百度智能云数据库品牌GaiaDB超赞!

https://baijiahao.baidu.com/s?id=1676074602279880529&wfr=spider&for=pc 再刚刚落幕的ABC SUMMIT 2020百度智能云智能计算峰会上,百度智能云正式对外发布百度智能云数据库品牌——GaiaDB,实现对既有产品能力和方案的整合

DevOps | 产研协同效能提升之评审、审批流、质量卡点

研发过程中有各种需求的评审、审批流和质量卡点,有的是为了质量把关,有的是为了彰显权力,还有一些是为了信息告知。本文主要讨论在软件开发过程中涉及的评审、审批和质量卡点三种情况,同时探讨对研发流程的影响,在这过程中如何去提效。 同团队内部评审 同团队之间的评审包括产品团队内部的PRD评审,RD团队内部的

vivo 自研Jenkins资源调度系统设计与实践

本文从目前业界实现Jenkins的高可用的实现方案,分析各方案的优缺点,引入vivo目前使用的Jenkins高可用方案,以及目前Jenkins资源的调度方案的设计实践和目前的落地运行效果。

vivo 自研鲁班分布式 ID 服务实践

本文介绍了什么是分布式id,分布式id的业务场景以及9种分布式id的实现方式,同时基于vivo内部IT的业务场景,介绍了自研鲁班分布式Id服务的实践。