ThreadLocal详细分析

ThreadLocal详细分析
目录

一、ThreadLocal简介

1、介绍

2、常用方法

3、案例

二、ThreadLocal原理分析

1、ThreadLocal的存储结构

2、set(T value)方法源码

3、get()方法

4、remove()方法

5、initialValue()方法

6、如何解决hash冲突问题

三、ThreadLocalMap的内存泄漏问题

1、如果key使用强引用

2、如果key使用了弱引用

四、总结

一、ThreadLocal简介

1、介绍

        多线程访问同一个共享变量的时候容易出现并发问题，因此为了保证线程安全性，我们都会采用加锁的方式。而ThreadLocal是除加锁方式之外的另一种保证线程安全性的方法。                        ThreadLocal通过每个线程保存一份资源的副本，且这个副本只能被当前线程访问。这样的话每个线程都拥有一份，那么自然而然也就不需要对资源竞争了。

        在JDK8之前，每个ThreadLocal都创建一个ThreadLocalMap，用线程作为ThreadLocalMap的key，要存储的局部变量作为ThreadLocalMap的value，这样就实现了各个线程的局部变量的隔离作用。

        而在JDK8之后，每个线程维护一个ThreadLocalMap，这个ThreadLocalMap的key是ThreadLocal实例本身，value才是真正要存储的变量副本。线程内部的Map由ThreadLocal维护，由ThreadLocal负责向map获取和设置线程的变量值。对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，互不干扰。
好处：
- 减少ThreadLocalMap存储的Entry数量：因为之前的存储数量由Thread的数量决定，现在是由ThreadLocal的数量决定。在实际运用当中，往往ThreadLocal的数量要少于Thread的数量
- 当Thread销毁之后，对应的ThreadLocalMap也会随之销毁，能减少内存的使用（但是不能避免内存泄漏问题，解决内存泄漏问题应该在使用完后及时调用remove()对ThreadMap里的Entry对象进行移除，由于Entry继承了弱引用类，会在下次GC时被JVM回收）
2、常用方法

在ThreadLocal类中，有以下几个比较常用的方法：
- get：用于获取 ThreadLocal 在当前线程中保存的变量副本。
- set：用于设置当前线程中变量的副本。
- remove：用于删除当前线程中变量的副本。如果此线程局部变量随后被当前线程读取，则其值将通过调用其 initialValue 方法重新初始化，除非其值由中间线程中的当前线程设置。这可能会导致当前线程中多次调用 initialValue 方法。
- initialValue：为 ThreadLocal 设置默认的 get 初始值，需要重写 initialValue 方法。
3、案例
```
public class TestThreadLocal {
    private String name;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
    public static void main(String[] args) {
        TestThreadLocal testThreadLocal = new TestThreadLocal();
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    testThreadLocal.setName(Thread.currentThread().getName() + "的信息");
                    System.out.println(Thread.currentThread().getName() + ": " + testThreadLocal.getName());
                }
            }).start();
        }
    }
}
```
执行结果：

从结果可以看出多个线程在访问同一个变量的时候出现的异常，线程间的数据没有隔离。下面我们来看下采用 ThreadLocal 的方式来解决这个问题的例子。
```
public class TestThreadLocal {
    private static ThreadLocal t = new ThreadLocal<>();
 
    private String name;
 
    public String getName() {
        return t.get();
    }
 
    public void setName(String name) {
        t.set(name);
    }
    public static void main(String[] args) {
        TestThreadLocal testThreadLocal = new TestThreadLocal();
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    testThreadLocal.setName(Thread.currentThread().getName() + "的信息");
                    System.out.println(Thread.currentThread().getName() + ": " + testThreadLocal.getName());
                }
            }).start();
        }
    }
}
```
执行结果：

二、ThreadLocal原理分析

1、ThreadLocal的存储结构

在Thread类中维护着ThreadLocal.ThreadLocalMap类型的成员threadLocals，这个成员用来存储当前线程独占的变量副本。ThreadLocalMap是ThreadLocal的静态内部类，它维护者一个Entry数组，用来存储键值对。
```
public class Thread implements Runnable {
    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;
}
static class ThreadLocalMap {
 
        static class Entry extends WeakReference> {
            /** The value associated with this ThreadLocal. */
            Object value;
 
            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }
}
```
可以看到：Entry的key是ThreadLocal对象，value则是传递进行的对象，即变量副本，且Entry继承了WeakReference。

2、set(T value)方法源码

源码如下：
```
    public void set(T value) {    
        //获取当前线程
        Thread t = Thread.currentThread();
        //获取threalLocals
        ThreadLocalMap map = getMap(t);
        //将ThreadLocal和值一起存入当前线程的ThreadLocalMap中
        if (map != null)
            //如果存在就调用map.set()，这里的this指的是调用此方法的ThreadLocal对象
            map.set(this, value);
        else
            createMap(t, value);
    }
    //获取当前线程维护的ThreadLocalMap
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
    //创建当前线程
    void createMap(Thread t, T firstValue) {
        //这里的this是调用此方法的threadLocal
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
```
在ThreadLocal的set方法中，首先获取当前线程，然后调用getMap(Thread t)获取当前线程中ThreaLocalMap类型的threadLocals字段。然后将ThreadLocal一块放入到当前线程的ThreadLocalMap中。如果获取到的Map不为空，则将参数设置到Map中，否则就创建Map，并设置初值。

3、get()方法

源码如下：
```
    public T get() {
        //获取当前线程
        Thread t = Thread.currentThread();
        //拿到threadLocals字段
        ThreadLocalMap map = getMap(t);
        //如果map存在
        if (map != null) {
            //获取对应的存储实体
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                //获取存储尸体对应的value值
                T result = (T)e.value;
                return result;
            }
        }
        //执行当前代码的两种情况：1、map不存在，说明此线程没有ThreadLocalMap对象；2、map存在，但是没有与当前ThreadLocal关联的Entry
        return setInitialValue();
    }
    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;
    }
```
执行流程：先获取到当前线程，并根据当前线程获取一个Map。如果获取的map不为空，则在Map中以ThreadLocal的引用作为key在map中获取对应的Entry。如果entry不为空则返回e.value；如果e为空或者Map为空，则通过initialValue函数获取初始值value，然后用ThreadLocal的引用和value作为firstKey和firstValue创建一个新的Map。

4、remove()方法

源码如下：
```
     public void remove() {
        // 获取当前线程对象中维护的ThreadLocalMap对象
         ThreadLocalMap m = getMap(Thread.currentThread());
        // 如果此map存在
         if (m != null)
            // 存在则调用map.remove
            // 以当前ThreadLocal为key删除对应的实体entry
             m.remove(this);
     }
```
执行流程：首先获取当前线程，并根据当前线程获取一个Map。如果获取的map不为空，则移除当前ThreadLocal对象对应的Entry。

5、initialValue()方法

源码如下：
```
/**
  * 返回当前线程对应的ThreadLocal的初始值
  * 此方法的第一次调用发生在，当线程通过get方法访问此线程的ThreadLocal值时
  * 除非线程先调用了set方法，在这种情况下，initialValue 才不会被这个线程调用。
  * 通常情况下，每个线程最多调用一次这个方法。
  *
  * 这个方法仅仅简单的返回null {@code null};
  * 如果想ThreadLocal线程局部变量有一个除null以外的初始值，
  * 必须通过子类继承{@code ThreadLocal} 的方式去重写此方法
  * 通常, 可以通过匿名内部类的方式实现
  *
  * @return 当前ThreadLocal的初始值
  */
protected T initialValue() {
    return null;
}
```
        该方法作用是返回该线程局部变量的初始值。从上面的代码我们得知，在set方法还未调用而先调用了get方法时才执行，并且仅执行1次，这个方法缺省实现直接返回一个null。如果想要一个除null之外的初始值，可以重写此方法。（备注：该方法是一个protected的方法，显然是为了让子类覆盖而设计的）

6、如何解决hash冲突问题

        从前面可以看到ThreadLocalMap是类似于Map的数据结构，但是它并没有实现Map接口，那么它也就不支持Map接口中的next方法。因此可以推断出：ThreadLocalMap并不是通过拉链法来解决hash冲突问题的。实际上，ThreadLocalMap是使用线性探测的方式来解决hash冲突的，即：根据初始key的hashcode值来确定元素在table数组中的位置，如果这个位置已经被其他的key占据，那么就通过算法寻找下一个位置，直到找到能够存放的位置为止。

        在前面查看set()方法源码的时候，当map为空时调用了cerateMap()方法，而该方法中调用了有参构造：ThreadLocalMap(ThreadLocal firstKey, Object firstValue)
```
     /*
      * firstKey : 本ThreadLocal实例(this)
      * firstValue ： 要保存的线程本地变量
      */
    ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
        //初始化table
        table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY];
        //计算索引(重点代码）
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        //设置值
        table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
        size = 1;
        //设置阈值
        setThreshold(INITIAL_CAPACITY);
    }
```
构造函数首先创建一个长度为16的Entry数组，然后计算出firstKey对应的索引，然后存储到table中，并设置size和threshold。

重点看一下计算索引这一块：
```
    private final int threadLocalHashCode = nextHashCode();
    
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }
//AtomicInteger是一个提供原子操作的Integer类，通过线程安全的方式操作加减,适合高并发情况下的使用
    private static AtomicInteger nextHashCode =  new AtomicInteger();
     //特殊的hash值
    private static final int HASH_INCREMENT = 0x61c88647;
```
这里定义了一个AtomicInteger类型，每次获取当前值并加上HASH_INCREMENT，HASH_INCREMENT = 0x61c88647,这个值跟斐波那契数列（黄金分割数）有关，其主要目的就是为了让哈希码能均匀的分布在2的n次方的数组里, 也就是Entry[] table中，这样做可以尽量避免hash冲突。

        关于& (INITIAL_CAPACITY - 1)
        计算hash的时候里面采用了hashCode & (size - 1)的算法，这相当于取模运算hashCode % size的一个更高效的实现。正是因为这种算法，我们要求size必须是2的整次幂，这也能保证在索引不越界的前提下，使得hash发生冲突的次数减小。

        来看下ThreadLocalMap中的set方法：
```
    private void set(ThreadLocal key, Object value) {
        ThreadLocal.ThreadLocalMap.Entry[] tab = table;
        int len = tab.length;
        //计算索引(重点代码，刚才分析过了）
        int i = key.threadLocalHashCode & (len-1);
        /**
         * 使用线性探测法查找元素（重点代码）
         */
        for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
             e != null;
             e = tab[i = nextIndex(i, len)]) {
            ThreadLocal k = e.get();
            //ThreadLocal 对应的 key 存在，直接覆盖之前的值
            if (k == key) {
                e.value = value;
                return;
            }
            // key为 null，但是值不为 null，说明之前的 ThreadLocal 对象已经被回收了，
           // 当前数组中的 Entry 是一个陈旧（stale）的元素
            if (k == null) {
                //用新元素替换陈旧的元素，这个方法进行了不少的垃圾清理动作，防止内存泄漏
                replaceStaleEntry(key, value, i);
                return;
            }
        }
    
    	//ThreadLocal对应的key不存在并且没有找到陈旧的元素，则在空元素的位置创建一个新的Entry。
            tab[i] = new Entry(key, value);
            int sz = ++size;
            /**
             * cleanSomeSlots用于清除那些e.get()==null的元素，
             * 这种数据key关联的对象已经被回收，所以这个Entry(table[index])可以被置null。
             * 如果没有清除任何entry,并且当前使用量达到了负载因子所定义(长度的2/3)，那么进行				 * rehash（执行一次全表的扫描清理工作）
             */
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
}
 
 /**
     * 获取环形数组的下一个索引
     */
    private static int nextIndex(int i, int len) {
        return ((i + 1 < len) ? i + 1 : 0);
    }
```
综上所述，代码执行流程如下：
1. 首先根据key计算出索引 i，然后查找i位置上的Entry
2. 若是Entry已经存在并且key等于传入的key，那么这时候直接给这个Entry赋新的value值
3. 若是Entry存在，但是key为null，则调用replaceStaleEntry来更换这个key为空的Entry
4. 不断循环检测，直到遇到为null的地方，这时候要是还没在循环过程中return，那么就在这个null的位置新建一个Entry，并且插入，同时size增加1
5. 最后调用cleanSomeSlots，清理key为null的Entry，最后返回是否清理了Entry，接下来再判断sz 是否>= thresgold达到了rehash的条件，达到的话就会调用rehash函数执行一次全表的扫描清理
三、ThreadLocalMap的内存泄漏问题

在前面我们看到了，ThreadLocalMap的Entry继承了WeakReference，其中key是弱引用，而value是强引用。如果ThreadLocal对象没有外部强引用来引用它，那么ThreadLocal对象会在下次GC时候被回收。此时，如果Entry中的key已经被回收，但是value又是强引用，并不会被垃圾收集器回收。如果创建ThreadLocal的线程一直持续运行，那么value就会一直得不到回收，从而产生内存泄漏。
在Java中有四种引用类型，这里介绍一下强引用和弱引用：
- 强引用（“Strong” Reference），就是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还“活着”，垃圾回收器就不会回收这种对象。
- 弱引用（WeakReference），垃圾回收器一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。
1、如果key使用强引用

如下图：

        假设在业务代码中使用完ThreadLocal ，threadLocal Ref被回收了。但是因为threadLocalMap的Entry强引用了threadLocal，造成threadLocal无法被回收。在没有手动删除这个Entry以及CurrentThread依然运行的前提下，始终有强引用链 threadRef->currentThread->threadLocalMap->entry，Entry就不会被回收（Entry中包括了ThreadLocal实例和value），导致Entry内存泄漏。也就是说，ThreadLocalMap中的key使用了强引用，是无法完全避免内存泄漏的。

2、如果key使用了弱引用

如下图：

        假设在业务代码中使用完ThreadLocal ，threadLocal Ref被回收了。由于ThreadLocalMap只持有ThreadLocal的弱引用，没有任何强引用指向threadlocal实例, 所以threadlocal就可以顺利被gc回收，此时Entry中的key=null。但是在没有手动删除这个Entry以及CurrentThread依然运行的前提下，也存在有强引用链 threadRef->currentThread->threadLocalMap->entry -> value ，value不会被回收，而这块value永远不会被访问到了，导致value内存泄漏。也就是说，ThreadLocalMap中的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中的任一方法的时候会被清除，从而避免内存泄漏。

        解决办法：使用ThreadLocal的set方法，显式调用remove方法。
```
ThreadLocal threadLocal = new ThreadLocal();
try {
    threadLocal.set("xxx");
    // ...
} finally {
    threadLocal.remove();
}
```
四、总结
- threadLocal操作的是每个线程自己的ThreadLocalMap，因此不会有线程的竞争。key是当前的threadlocal对象，value是当前线程放在这个threadlocal里面的值。
- ThreadLocalMap是基于开放定址法（线性探测再散列）实现的hash表，这里没有采用HashMap的数组加链表的实现方式是因为这里的场景决定了hash表中不会有太多的值，通过采用独特的斐波那契散列求hash值，可以极大的降低hash冲突概率，访问数据速度也比HashMap快。
- ThreadLocalMap的实现类似WeakHashMap实现，都通过WeakReference封装了key值，防止内存泄漏；
- ThreadLocalMap实现的挺复杂的，主要是为了避免内存泄露，加了好多处理过期数据的操作，这就在线程中添加了多余的操作。所以如果确定ThreadLocal没有用的话，可以调用ThreadLocal的remove()方法，这样就避免了在ThreadLocalMap中查找过期数据并处理的操作。
相关阅读:
【JavaEE初阶】 JUC(java.util.concurrent) 的常见类
 软件评测师之流水线
 VoLTE基础自学系列 | 什么是VoLTE中的Silent Redial？它和CSFB什么关系？
深入浅出Spring Cloud Netflix - Ribbon
如何用项目管理工具跟踪项目进度？
用Unity实现景深效果
 My Ninety-ninth Page - 两个字符串的删除操作 - By Nicolas
JS 繁简转换优化
 Flink / SQL - 6.Tumble、Slide、Session、Over Window 详解
 我的第一个项目(三)：注册登陆功能(后端)
原文地址：https://blog.csdn.net/weixin_47382783/article/details/126130528

一、ThreadLocal简介

1、介绍

2、常用方法

3、案例

二、ThreadLocal原理分析

1、ThreadLocal的存储结构

2、set(T value)方法源码

3、get()方法

4、remove()方法

5、initialValue()方法

6、如何解决hash冲突问题

三、ThreadLocalMap的内存泄漏问题

1、如果key使用强引用

2、如果key使用了弱引用

四、总结