ThreadLocal学习

最新推荐文章于 2023-09-24 13:38:36 发布

Tian_ccc

最新推荐文章于 2023-09-24 13:38:36 发布

阅读量213

点赞数

分类专栏： Java学习文章标签： java

本文链接：https://blog.csdn.net/bktytcc/article/details/118607873

版权

Java学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文详细讲解了ThreadLocal的工作原理，包括其定义、方法详解、核心结构、优点与缺点，以及与synchronized关键字的区别。重点讨论了内存泄漏问题及如何避免，并提供了ThreadLocal在多线程环境下的实际应用案例。

摘要由CSDN通过智能技术生成

ThreadLocal

ThreadLocal详解

ThreadLocal详解

1、定义：

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

Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。

优点：

传递数据 ：保存每个线程绑定的数据，在需要的地方可以直接获取, 避免参数直接传递带来的代码耦合问题
线程隔离 ：各线程之间的数据相互隔离却又具备并发性，避免同步方式带来的性能损

缺点：

1、不能父子线程之间传递。即在子线程中无法访问在父线程中设置的本地线程变量。后来为了解决这个问题，引入了一个新的类InheritableThreadLocal。

2、容易造成内存泄漏

2、ThreadLocal 方法

public T get() { } // 用来获取ThreadLocal在当前线程中保存的变量副本

public void set(T value) { } //set()用来设置当前线程中变量的副本

public void remove() { } //remove()用来移除当前线程中变量的副本

protected T initialValue() { } //initialValue()是一个protected方法，一般是用来在使用时进行重写的，这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。

1、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对象
        // 调用setInitialValue进行初始化
        return setInitialValue();
    }

    /**
     * set的变样实现，用于初始化值initialValue，
     * 用于代替防止用户重写set()方法
     *
     * @return the initial value 初始化后的值
     */
    private T setInitialValue() {
        // 调用initialValue获取初始化的值
        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）并将此实体entry作为第一个值存放至ThreadLocalMap中
            createMap(t, value);
        // 返回设置的值value
        return 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);
    }

A. 首先获取当前线程

B. 根据当前线程获取一个Map

C. 如果获取的Map不为空，则在Map中以ThreadLocal的引用作为key来在Map中获取对应的value e，否则转到E

D. 如果e不为null，则返回e.value，否则转到E

E. Map为空或者e为空，则通过initialValue函数获取初始值value，然后用ThreadLocal的引用和value作为firstKey和firstValue创建一个新的Map

总结: 先获取当前线程的 ThreadLocalMap 变量，如果存在则返回值，不存在则创建并返回初始值。

2、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）并将此实体entry作为第一个值存放至ThreadLocalMap中
            createMap(t, value);
    }

A. 首先获取当前线程，并根据当前线程获取一个Map

B. 如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal的引用作为key）

C. 如果Map为空，则给该线程创建 Map，并设置初始值

3、remove()方法

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

4、initialValue()方法

/**
  * 返回当前线程对应的ThreadLocal的初始值
  
  * 此方法的第一次调用发生在，当线程通过{@link #get}方法访问此线程的ThreadLocal值时
  * 除非线程先调用了 {@link #set}方法，在这种情况下，
  * {@code 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的方法，显然是为了让子类覆盖而设计的）

3、ThreadLocal核心结构

早期设计：

每个ThreadLocal类都创建一个Map，然后用线程的ID threadID作为Map的key，要存储的局部变量作为Map的value，这样就能达到各个线程的局部变量隔离的效果。这是最简单的设计方法

JDK8之后设计：

JDK8 ThreadLocal的设计是：每个Thread维护一个ThreadLocalMap哈希表，这个哈希表的key是ThreadLocal实例本身，value才是真正要存储的值Object。

（1）每个Thread线程内部都有一个Map (ThreadLocalMap)

（2） Map里面存储ThreadLocal对象（key）和线程的变量副本（value）

（3）Thread内部的Map是由ThreadLocal维护的，由ThreadLocal负责向map获取和设置线程的变量值。

（4）对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，互不干扰。

在这里插入图片描述

优点：

1）这样设计之后每个Map存储的Entry数量就会变少，因为之前的存储数量由Thread的数量决定，现在是由ThreadLocal的数量决定。（并不是每个线程都需要创建ThreadLocal，看自己需求）

2）当Thread销毁之后，对应的ThreadLocalMap也会随之销毁，能减少内存的使用。

4、ThreadLocalMap

在这里插入图片描述

ThreadLocalMap是ThreadLocal的内部类，没有实现Map接口，用独立的方式实现了Map的功能，其内部的Entry也独立实现。

和HashMap的最大的不同在于，ThreadLocalMap结构非常简单，没有next引用，也就是说ThreadLocalMap中解决Hash冲突的方式并非链表的方式，而是采用线性探测的方式。

线性探测

在ThreadLocalMap中，也是用Entry来保存K-V结构数据的。但是Entry中key只能是ThreadLocal对象，这点被Entry的构造方法已经限定死了。

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

    Entry(ThreadLocal k, Object v) {
    	// ThreadLocal为弱引用
        super(k);
        value = v;
    }
}

注意：
Entry继承自WeakReference（弱引用，生命周期只能存活到下次GC前），但只有Key是弱引用类型的，Value并非弱引用。

由于ThreadLocalMap的key是弱引用，而Value是强引用。这就导致了一个问题，ThreadLocal在没有外部对象强引用时，发生GC时弱引用Key会被回收，而Value不会回收。

当线程没有结束，但是ThreadLocal已经被回收，则可能导致线程中存在ThreadLocalMap<null, Object>的键值对，造成内存泄露。（ThreadLocal被回收，ThreadLocal关联的线程共享变量还存在）导致内存泄漏

（1）内存泄漏相关概念

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

（2）弱引用相关概念
Java中的引用有4种类型: 强、软、弱、虚。当前这个问题主要涉及到强引用和弱引用:

Java 关于强引用，软引用，弱引用和虚引用的区别与用法

jvm就像一个国家,gc就是城管,强引用就是当地人,软引用就是移民的人,弱引用就是黑户口,哪天城管逮到就遣走,虚引用就是一个带病的黑户口,指不定哪天自己就挂了

5、ThreadLocal类与synchronized关键字

/**
 * @author Tian Chen
 * @date： 2021/7/1
 * Copyright (C), 2017-2021, 网联商务
 **/
public class TestThreadLocal {
    private String content;
    // 创建ThreadLocal
    ThreadLocal<String> stringLocal = new ThreadLocal<String>();

    public String getContent() {
        return content;
        // 获取当前线程变量
//        return stringLocal.get();
    }

    public void setContent(String content) {
        this.content = content;
        // 线程绑定变量
//        stringLocal.set(content);
    }

    public static void main(String[] args) {
        TestThreadLocal testThreadLocal = new TestThreadLocal();
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (TestThreadLocal.class) {
                        testThreadLocal.setContent(Thread.currentThread().getName() + "数据");
                        System.out.println("-----------------------");
                        System.out.println(Thread.currentThread().getName() + "---->" + testThreadLocal.getContent());

                    }
                }
            });
            thread.setName("线程" + i);
            thread.start();
        }
    }

}

区别：

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

总结：

使用ThreadLocal更为合适,因为这样可以使程序拥有更高的并发性。

6、Demo

/**
 * @author Tian Chen
 * @date： 2021/7/1
 * Copyright (C), 2017-2021, 网联商务
 **/
public class TestThreadLocal {
    private String content;
    // 创建ThreadLocal
    ThreadLocal<String> stringLocal = new ThreadLocal<String>();

    public String getContent() {
        return content;
        // 获取当前线程变量
//        return stringLocal.get();
    }

    public void setContent(String content) {
        this.content = content;
        // 线程绑定变量
//        stringLocal.set(content);
    }

    public static void main(String[] args) {
        TestThreadLocal testThreadLocal = new TestThreadLocal();
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    testThreadLocal.setContent(Thread.currentThread().getName() + "数据");
                    System.out.println("-----------------------");
                    System.out.println(Thread.currentThread().getName() + "---->" + testThreadLocal.getContent());
                }
            });
            thread.setName("线程" + i);
            thread.start();
        }
    }
    
}

7、问题

1、内存泄漏和ThreadLocalMap种Key的弱引用有关系嘛？内存泄漏真正原因是什么？

没有关系。在这里插入图片描述

**真正原因：**由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应的key就会导致内存泄漏

2、如何避免泄漏

1、使用完线程共享变量后，显示调用ThreadLocalMap.remove方法清除线程共享变量；
既然Key是弱引用，那么我们要做的事，就是在调用ThreadLocal的get()、set()方法时完成后再调用remove方法，将Entry节点和Map的引用关系移除，这样整个Entry对象在GC Roots分析后就变成不可达了，下次GC的时候就可以被回收。

2、JDK建议ThreadLocal定义为private static，避免重复创建实例，这样ThreadLocal的弱引用问题则不存在了。（ThreadLocal类的目的是为每个线程单独维护一个变量的值，避免线程间对同一变量的竞争访问，适用于一个变量在每个线程中需要有自己独立的值的场合。）

ThreadLocal变量通常设置为static的原因

ThreadLocal就跟加锁完要解锁一样，用完就需要清理。

3、那么为什么key要用弱引用呢?

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

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