Threadlocal的解析

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量248 收藏
点赞数
文章标签： java 开发语言 后端
原文链接：https://blog.csdn.net/weixin_44050144/article/details/113061884
版权

ThreadLocal概述

ThreadLocal是线程变量，ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。

它具有3个特性：

  1. 线程并发：在多线程并发场景下使用。
  2. 传递数据：可以通过ThreadLocal在同一线程，不同组件中传递公共变量。
  3. 线程隔离：每个线程变量都是独立的，不会相互影响。

在不使用ThreadLocal的情况下，变量不隔离，得到的结果具有随机性

public class Demo {
    private String variable;

    public String getVariable() {
        return variable;
    }

    public void setVariable(String variable) {
        this.variable = variable;
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                demo.setVariable(Thread.currentThread().getName());
                System.out.println(Thread.currentThread().getName()+" "+demo.getVariable());
            }).start();
        }
    }
}

输出结果：

Thread-0 Thread-3
Thread-4 Thread-4
Thread-1 Thread-1
Thread-2 Thread-2
Thread-3 Thread-3

在不使用ThreadLocal的情况下，变量隔离，每个线程有自己专属的本地变量variable，线程绑定了自己的variable，只对自己绑定的变量进行读写操作。 

public class Demo {
    private ThreadLocal<String> variable = new ThreadLocal<>();

    public String getVariable() {
        return variable.get();
    }

    public void setVariable(String variable) {
        this.variable.set(variable);
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                demo.setVariable(Thread.currentThread().getName());
                System.out.println(Thread.currentThread().getName()+" "+demo.getVariable());
            }).start();
        }
    }
}

输出结果：

Thread-0 Thread-0
Thread-3 Thread-3
Thread-1 Thread-1
Thread-2 Thread-2
Thread-4 Thread-4

结论：ThreadLocal很好的解决了多线程之间数据隔离的问题。

 ThreadLocal类与synchronized关键字

        用synchronized代码块实现的效果：

public class Demo4 {
    private String variable;

    public String getVariable() {
        return variable;
    }

    public void setVariable(String variable) {
        this.variable = variable;
    }

    public static void main(String[] args) {
        Demo4 demo = new Demo4();
        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                synchronized (Demo4.class){
                    demo.setVariable(Thread.currentThread().getName());
                    System.out.println(Thread.currentThread().getName()+" "+demo.getVariable());
                }
            }).start();
        }
    }
}

输出结果：

Thread-0 Thread-0
Thread-4 Thread-4
Thread-3 Thread-3
Thread-2 Thread-2
Thread-1 Thread-1

         从结果可以发现, 加锁确实可以解决这个问题，但是在这里我们强调的是线程数据隔离的问题，并不是多线程共享数据的问题, 在这个案例中使用synchronized关键字是不合适的。 

ThreadLocal与synchronized的区别

        ThreadLocal模式与synchronized关键字都用于处理多线程并发访问变量的问题, 不过两者处理问题的角度和思路不同。

synchronizedThreadLocal
原理

同步机制采用’以时间换空间’的方式,

只提供了一份变量,让不同的线程排队访问

ThreadLocal采用’以空间换时间’的方式, 为每一个线程都提供了一份变量的副本,从而实现同时访问而相不干扰
侧重点多个线程之间访问资源的同步多线程中让每个线程之间的数据相互隔离

ThreadLocal的核心方法源码

        基于ThreadLocal的内部结构，我们继续分析它的核心方法源码，更深入的了解其操作原理。

除了构造方法之外， ThreadLocal对外暴露的方法有以下4个：

  • set()方法用于保存当前线程的副本变量值。
  • get()方法用于获取当前线程的副本变量值。
  • initialValue()为当前线程初始副本变量值。
  • remove()方法移除当前线程的副本变量值。

get方法

    /**
     * 返回当前线程中保存ThreadLocal的值
     * 如果当前线程没有此ThreadLocal变量，
     * 则它会通过调用{@link #initialValue} 方法进行初始化值
     *
     * @return 返回当前线程对应此ThreadLocal的值
     */
    public T get() {
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取此线程对象中维护的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        // 如果此map存在
        if (map != null) {
            // 以当前的ThreadLocal 为 key，调用getEntry获取对应的存储实体e
            ThreadLocalMap.Entry e = map.getEntry(this);
            // 对e进行判空 
            if (e != null) {
                @SuppressWarnings("unchecked")
                // 获取存储实体 e 对应的 value值
                // 即为我们想要的当前线程对应此ThreadLocal的值
                T result = (T)e.value;
                return result;
            }
        }
        /*
        	初始化 : 有两种情况有执行当前代码
        	第一种情况: map不存在，表示此线程没有维护的ThreadLocalMap对象
        	第二种情况: map存在, 但是没有与当前ThreadLocal关联的entry
         */
        return setInitialValue();
    }

    /**
     * 初始化
     *
     * @return the initial value 初始化后的值
     */
    private T setInitialValue() {
        // 调用initialValue获取初始化的值
        // 此方法可以被子类重写, 如果不重写默认返回null
        T value = initialValue();
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取此线程对象中维护的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        // 判断map是否存在
        if (map != null)
            // 存在则调用map.set设置此实体entry
            map.set(this, value);
        else
            // 1）当前线程Thread 不存在ThreadLocalMap对象
            // 2）则调用createMap进行ThreadLocalMap对象的初始化
            // 3）并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
            createMap(t, value);
        // 返回设置的值value
        return value;
    }

       get方法首先获取当前线程，然后得到当前线程的 ThreadLocalMap 变量即 threadLocals，然后将自己作为 key 从 ThreadLocalMap 中找到 Entry ，最终返回 Entry 里面的 value 值。

这里我们再看一下 key 是如何从 ThreadLocalMap 中找到 Entry 的，即map.getEntry(this)是如何实现的，其实很简单。

图片

Set方法 

  /**
     * 设置当前线程对应的ThreadLocal的值
     *
     * @param value 将要保存在当前线程对应的ThreadLocal的值
     */
    public void set(T value) {
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取此线程对象中维护的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        // 判断map是否存在
        if (map != null)
            // 存在则调用map.set设置此实体entry
            map.set(this, value);
        else
            // 1）当前线程Thread 不存在ThreadLocalMap对象
            // 2）则调用createMap进行ThreadLocalMap对象的初始化
            // 3）并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
            createMap(t, value);
    }

 /**
     * 获取当前线程Thread对应维护的ThreadLocalMap 
     * 
     * @param  t the current thread 当前线程
     * @return the map 对应维护的ThreadLocalMap 
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
	/**
     *创建当前线程Thread对应维护的ThreadLocalMap 
     *
     * @param t 当前线程
     * @param firstValue 存放到map中第一个entry的值
     */
	void createMap(Thread t, T firstValue) {
        //这里的this是调用此方法的threadLocal
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

          首先获取当前线程，并根据当前线程获取一个Map， 如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal的引用作为key），如果Map为空，则给该线程创建 Map，并设置初始值。

        看下怎么调用ThreadLocalMap设置值的

图片

可以看到 set 的逻辑也很清晰。

先通过 key 的 hash 值计算出一个数组下标，然后看看这个下标是否被占用了，如果被占了看看是否就是要找的 Entry 。

如果是则进行更新，如果不是则下标++，即往后遍历数组，查找下一个位置，找到空位就 new 个 Entry 然后把坑给占用了。

当然，这种数组操作一般免不了阈值的判断，如果超过阈值则需要进行扩容。

 remove方法

 /**
     * 删除当前线程中保存的ThreadLocal对应的实体entry
     */
     public void remove() {
        // 获取当前线程对象中维护的ThreadLocalMap对象
         ThreadLocalMap m = getMap(Thread.currentThread());
        // 如果此map存在
         if (m != null)
            // 存在则调用map.remove
            // 以当前ThreadLocal为key删除对应的实体entry
             m.remove(this);
     }


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


private void remove(ThreadLocal<?> key) {
    //使用hash方式，计算当前ThreadLocal变量所在table数组位置
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);
    //再次循环判断是否在为ThreadLocal变量所在table数组位置
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        if (e.get() == key) {
            //调用WeakReference的clear方法清除对ThreadLocal的弱引用
            e.clear();
            //清理key为null的元素
            expungeStaleEntry(i);
            return;
        }
    }
}

       首先获取当前线程，并根据当前线程获取线程对象维护的ThreadLocalMap对象，如果ThreadLocalMap对象不为空，则移除ThreadLocal对象对应的entry。

initialValue方法

/**
  * 返回当前线程对应的ThreadLocal的初始值
  
  * 此方法的第一次调用发生在，当线程通过get方法访问此线程的ThreadLocal值时
  * 除非线程先调用了set方法，在这种情况下，initialValue 才不会被这个线程调用。
  * 通常情况下，每个线程最多调用一次这个方法。
  *
  * <p>这个方法仅仅简单的返回null {@code null};
  * 如果程序员想ThreadLocal线程局部变量有一个除null以外的初始值，
  * 必须通过子类继承{@code ThreadLocal} 的方式去重写此方法
  * 通常, 可以通过匿名内部类的方式实现
  *
  * @return 当前ThreadLocal的初始值
  */
protected T initialValue() {
    return null;
}

此方法的作用是 返回该线程局部变量的初始值。

（1） 这个方法是一个延迟调用方法，从上面的代码我们得知，在set方法还未调用而先调用了get方法时才执行，并且仅执行1次。

（2）这个方法缺省实现直接返回一个null。

（3）如果想要一个除null之外的初始值，可以重写此方法。（备注： 该方法是一个protected的方法，显然是为了让子类覆盖而设计的）

弱引用和内存泄漏

  Java的四种引用类型：

  • 强引用：我们常常new出来的对象就是强引用类型，只要强引用存在，垃圾回收器将永远不会回收被引用的对象，哪怕内存不足的时候
  • 软引用：使用SoftReference修饰的对象被称为软引用，软引用指向的对象在内存要溢出的时候被回收
  • 弱引用：使用WeakReference修饰的对象被称为弱引用，只要发生垃圾回收，若这个对象只被弱引用指向，那么就会被回收
  • 虚引用：虚引用是最弱的引用，在 Java 中使用 PhantomReference 进行定义。虚引用中唯一的作用就是用队列接收对象即将死亡的通知

 内存泄漏相关概念

  • Memory overflow:内存溢出，没有足够的内存提供申请者使用。
  • Memory leak: 内存泄漏是指程序中已动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。内存泄漏的堆积终将导致内存溢出

如果key使用强引用

        ​ 假设ThreadLocalMap中的key使用了强引用，那么会出现内存泄漏吗？

​         此时ThreadLocal的内存图（实线表示强引用）如下：

在这里插入图片描述

​ 假设在业务代码中使用完ThreadLocal ，threadLocal Ref被回收了。

​ 但是因为threadLocalMap的Entry强引用了threadLocal，造成threadLocal无法被回收。

​ 在没有手动删除这个Entry以及CurrentThread依然运行的前提下，始终有强引用链 threadRef->currentThread->threadLocalMap->entry，Entry就不会被回收（Entry中包括了ThreadLocal实例和value），导致Entry内存泄漏。

​ 也就是说，ThreadLocalMap中的key使用了强引用， 是无法完全避免内存泄漏的。
如果key使用弱引用

那么ThreadLocalMap中的key使用了弱引用，会出现内存泄漏吗？

​ 此时ThreadLocal的内存图（实线表示强引用，虚线表示弱引用）如下：在这里插入图片描述

 

​ 同样假设在业务代码中使用完ThreadLocal ，threadLocal Ref被回收了。

​ 由于ThreadLocalMap只持有ThreadLocal的弱引用，没有任何强引用指向threadlocal实例, 所以threadlocal就可以顺利被gc回收，此时Entry中的key=null。

​ 但是在没有手动删除这个Entry以及CurrentThread依然运行的前提下，也存在有强引用链 threadRef->currentThread->threadLocalMap->entry -> value ，value不会被回收， 而这块value永远不会被访问到了，导致value内存泄漏。

​ 也就是说，ThreadLocalMap中的key使用了弱引用， 也有可能内存泄漏。
 

出现内存泄漏的真实原因

    在以上两种内存泄漏的情况中，都有两个前提：

  1. 没有手动删除这个Entry
  2. CurrentThread依然运行

        ​ 第一点很好理解，只要在使用完ThreadLocal，调用其remove方法删除对应的Entry，就能避免内存泄漏。

        ​ 第二点稍微复杂一点， 由于ThreadLocalMap是Thread的一个属性，被当前线程所引用，所以它的生命周期跟Thread一样长。那么在使用完ThreadLocal之后，如果当前Thread也随之执行结束，ThreadLocalMap自然也会被gc回收，从根源上避免了内存泄漏。

        ​ 综上，ThreadLocal内存泄漏的根源是：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key就会导致内存泄漏。

为什么使用弱引用

     无论ThreadLocalMap中的key使用哪种类型引用都无法完全避免内存泄漏，跟使用弱引用没有关系。

​    要避免内存泄漏有两种方式：

  1. 使用完ThreadLocal，调用其remove方法删除对应的Entry

  2. 使用完ThreadLocal，当前Thread也随之运行结束

相对第一种方式，第二种方式显然更不好控制，特别是使用线程池的时候，线程结束是不会销毁的。

         也就是说，只要记得在使用完ThreadLocal及时的调用remove，无论key是强引用还是弱引用都不会有问题。那么为什么key要用弱引用呢？

        ​ 事实上，在ThreadLocalMap中的set/getEntry方法中，会对key为null（也即是ThreadLocal为null）进行判断，如果为null的话，那么是会对value置为null的。

结论：
​         这就意味着使用完ThreadLocal，CurrentThread依然运行的前提下，就算忘记调用remove方法，弱引用比强引用可以多一层保障：弱引用的ThreadLocal会被回收，对应的value在下一次ThreadLocalMap调用set,get,remove中的任一方法的时候会被清除，从而避免内存泄漏。

学习中的小亮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ThreadLocal
qq_45591339的博客
01-13 203
ThreadLocal 是什么？ 线程变量，往ThreadLocal中填充的变量属于线程私有的。 public static void main(String[] args) { ThreadLocal<String> tl = new ThreadLocal<>(); for (int i = 0; i < 20; i++) { new Thread(() -> { tl.set(T
ThreadLocal解析
qq_38409944的博客
03-03 312
ThreadLocal ThreadLocal 中有一个静态内部类 ThreadLocalMap,ThreadLocalMap 维护一个 Entry 数组,大小为 16,Entry 以弱引用的 ThreadLocal 作为 key,value 就是我们要设置的值。在 Thread 内部维护一个 ThreadLocalMap 的变量,也就是说每个线程都有一个 ThreadLocalMap 的变量,互...
ThreadLocal类特点
夏沐的博客
11-15 1074
    ThreadLocal为解决多线程程序的并发问题提供了一种新的思路，其主要特点如下：     （1）ThreadLocal的类声明： public class ThreadLocal&lt;T&gt;     可以看出ThreadLocal并没有继承自Thread，也没有实现Runnable接口。     （2）ThreadLocal类为每一个线程都维护了自己独有的变量拷贝，每...
ThreadLocal的主要特点：
eeeeeeeeei的博客
03-24 1133
虽然没有直接的性能比较数据，但我们可以推测，由于Java 11中的JVM和垃圾回收器的改进，ThreadLocal在Java 11上的性能可能会有所提升，特别是在内存泄漏问题和垃圾回收效率方面。然而，ThreadLocal的基本工作原理和数据结构在Java 8和Java 11中保持不变，因此性能差异可能不会特别显著。具体性能表现还需要通过实际的基准测试来确定。
ThreadLocal源码分析---ThreadLocalMap中的Entry
qq_32019367的博客
12-14 1476
最近公司的项目终于快结束了，终于有时间执行下个阶段的学习了，这个阶段我主要是看一下Android系统的源码。首先从Handler开始，Handler看过很多次，也是烂大街的东西了。每次看的时候，ThreadLocal基本上都被我略过了，这次我想仔细的研究一下，然后发现了好多新大陆，而ThreadLocal也是多线程中比较重要的东西。这次我的博客以短篇为主，不再长篇大论，只研究小知识点，好了，我们进入正题。 参考博客：【JAVA并发编程系列】ThreadLocal ThreadLocalMap本身就是一个
史上最全ThreadLocal 详解
qq_43842093的博客
09-05 8982
ThreadLocal叫做线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的，也就是说该变量是当前线程独有的变量。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。ThreadLoal 变量，线程局部变量，同一个 ThreadLocal 所包含的对象，在不同的 Thread 中有不同的副本。因为每个 Thread 内有自己的实例副本，且该副本只能由当前 Thread 使用。
ThreadLocal源码解析
01-20
ThreadLocal类的作用：为每个线程创建独立的副本，从而保证了线程安全。 ThreadLocal使用代码示例： public class MyThreadLocalTest { private ThreadLocal threadLocal=new ThreadLocal(){ @Override protected...
Java源码解析ThreadLocal及使用场景
08-26
Java源码解析ThreadLocal及使用场景 ThreadLocal是Java中一个非常重要的类，它在多线程环境下经常使用，用于提供线程本地变量。这些变量使每个线程都有自己的一份拷贝，使得多个线程可以独立地使用变量，不会彼此...
java ThreadLocal使用案例详解
08-27
スレッド不安全的解析 在我们的示例代码中，我们可以看到一个典型的线程不安全的场景。在DateUtil类中，我们使用了synchronized关键字来同步parseymdhms()方法，以避免线程安全问题。然而，这种解决方案是非常不...
深入解析Java中ThreadLocal线程类的作用和用法
09-02
Java中的ThreadLocal是多线程编程中一个非常重要的工具，它的设计目的是为了解决线程间的共享变量问题，提供一种线程隔离的数据存储方式。ThreadLocal并不是一个Thread类的实例，而是一个用来创建线程局部变量的类。...
ThreadPoolExecutor源码解析.pdf
11-26
《ThreadPoolExecutor源码解析》 ThreadPoolExecutor是Java并发编程中重要的组件，它是ExecutorService接口的实现，用于管理和调度线程的执行。理解其源码有助于我们更好地控制并发环境下的任务执行，提高系统的...
ThreadLocal（原理）
qianhuan_的博客
07-31 126
暂定
ThreadLocal类详解
敲代码的小小酥的博客
11-01 706
ThreadLocal原理详解
ThreadLocal还存在内存泄漏？源码级别解读
风团团
03-09 295
前言：ThreadLocal平常用的比较少，但是面试有被问到好多次、痛定思痛准备花几天自己好好看一下源码。小白看源码系列，以后有更深层次的研究，在将博客更新plus，我的技术在长大、我的博客亦然要长大。threallocal到底是个啥东东呢？下面一段话摘自源码 This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that a
ThreadLocal原理及内存泄漏模拟
Codefarmer_uzi的博客
09-29 304
ThreadLocal原理 ThreadLocal是Java中所提供的线程本地存储机制，可以利⽤该机制将数据缓存在某个线程内部，成为线程内的局部变量 该线程可以在任意时刻、任意⽅法中获取缓存的数据 这样每个线程都自己管理自己的局部变量，别的线程操作的数据不会产生影响，互不影响 一般使用ThreadLocal，官方建议定义为private static ThreadLocal底层是通过ThreadLocalMap来实现的，每个Thread对象（注意不是ThreadLocal对 象）中都存在⼀个ThreadL
ThreadLocal.Entry的key为何使用弱引用
m0_47039719的博客
09-28 420
当当前线程的threadlocals属性赋值ThreadLoaclMap的实例后，ThreadLoaclMap便伴随着整个
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1138
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java面试必备：ThreadLocal深度解析
ThreadLocal则为每一个线程都提供了变量的副本，让它们各自独立修改，从而避开了同步。这种方式极大地提高了程序的执行效率，但也增加了内存消耗，因为每个线程都有自己的副本。 二、ThreadLocal的工作原理 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值