ThreadLocal的原理分析以及ThreadLocalMap的源码分析

目录

ThreadLocal的简单使用

 ThreadLocal 的数据结构

ThreadLocal的核心方法介绍

set

get

remove

ThreadLocalMap源码分析

ThreadLocalMap的内存泄漏问题

构造函数

getEntry方法

 set方法

---

 

1. 什么是ThreadLocal？
   ThreadLocal类顾名思义可以理解为线程本地变量。也就是说如果定义了一个ThreadLocal，每个线程往这个ThreadLocal中读写是线程隔离，互相之间不会影响的。它提供了一种将可变数据通过每个线程有自己的独立副本从而实现线程封闭的机制。

2. 它大致的实现思路是怎样的？
   Thread类有一个类型为ThreadLocal.ThreadLocalMap的实例变量threadLocals，也就是说每个线程有一个自己的ThreadLocalMap。ThreadLocalMap有自己的独立实现，可以简单地将它的key视作ThreadLocal，value为代码中放入的值（实际上key并不是ThreadLocal本身，而是它的一个弱引用）。每个线程在往某个ThreadLocal里塞值的时候，都会往自己的ThreadLocalMap里存，读也是以某个ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离。

我们可以得知ThreadLocal 的作用是：提供线程内的局部变量，不同线程之间不会相互干扰，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或者组件之间一些公共变量传递的复杂度。

一句话就是：线程并发下的数据隔离以及数据传递

ThreadLocal的简单使用

先来看下简单的使用，比如下面的demo，我们开启五个线程，分别去设置每个线程自己的content ，再get

package com.cjian.threadlocal;

/**
 * 需求：线程隔离
 * 在多线程并发的场景下，每个线程中的变量都是相互独立的
 * @description:
 * @author: CJ
 * @time: 2020/11/13 16:34
 */
public class ThreadLocalDemo {

    private String content;

    public String getContent() {
        return content;
    }

    public void  setContent(String content) {
         this.content = content;
    }

    public static void main(String[] args) {
        ThreadLocalDemo demo = new ThreadLocalDemo();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                    demo.setContent(Thread.currentThread().getName() + "的数据");
                    System.out.println(Thread.currentThread().getName() + "---->" + demo.getContent());
            }).start();
        }
    }
}

输出为：

多运行几次每次的结果会不相同，但是有一个共同点->不同线程之间的content乱了，如果想实现每个线程准确的获取自己设置的content值，应该怎么做呢？

我们首先想到的就是使用synchronized关键字，我没来试一下：

package com.cjian.threadlocal;

public class ThreadLocalDemo {

    private String content;

    public String getContent() {
        return content;

    public void  setContent(String content) {
         this.content = content;
    }

    public static void main(String[] args) {
        ThreadLocalDemo demo = new ThreadLocalDemo();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                synchronized (demo) {
                    demo.setContent(Thread.currentThread().getName() + "的数据");
                    System.out.println(Thread.currentThread().getName() + "---->" + demo.getContent());
                }
            }).start();
        }
    }
}

结果如我们所愿：

但是呢，问题来了，在高并发的情况下使用synchronized会导致程序的并发性降低，那还有其他办法吗？下面就是主角了：使用 ThreadLocal

我们 先来实现以下上面的demo：

package com.cjian.threadlocal;

public class ThreadLocalDemo {
    ThreadLocal tl = new ThreadLocal<>();

    private String content;

    public String getContent() {
        return tl.get();
    }

    public void  setContent(String content) {
        tl.set(content);
    }

    public static void main(String[] args) {
        ThreadLocalDemo demo = new ThreadLocalDemo();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                    demo.setContent(Thread.currentThread().getName() + "的数据");
                    System.out.println(Thread.currentThread().getName() + "---->" + demo.getContent());
            }).start();
        }
    }
}

运行结果：

虽然ThreadLocal 和synchronized都能解决多线程并发访问变量的问题，但两者是有区别的：

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

---

那么ThreadLocal 底层原理是什么呢？

 ThreadLocal 的数据结构

如果我们不看源码的话，我们可能会猜测每个ThreadLocal都会创建一个Map,然后用线程作为map的key，要存储的局部变量作为value，JDK早期确实是这样设计的，但现在早不是了。

JDK1.8中:每个ThreadLocal 维护一个ThreadLocalMap,这个map的key是ThreadLocal实例本身，value是要存储的值：

1. 每个Thread线程内部都有一个ThreadLocalMap；
2. ThreadLocalMap里面存储ThreadLocal对象（key）和线程的变量副本（value）
3. ThreadLocal内部的Map是由ThreadLocal维护的，由ThreadLocal负责向map获取和设置线程的变量值

这样设计的好处：

每个Map存储的Entry减少；当Thread销毁的时候ThreadLocalMap也会随之销毁，减少内存的使用

---

我们继续分析ThreadLocal的源码：

主要由下面四个方法：

1. protected T initialValue() ：返回当前线程局部变量的初始值
2. public void set(T value)：设置当前线程绑定的局部变量
3. public T get()：获取当前线程绑定的局部变量
4. public void remove()：移除当前线程绑定的局部变量

ThreadLocal的核心方法介绍

set

//设置当前线程对应的ThreadLocal的值
public void set(T value) {
        //获取当前线程
        Thread t = Thread.currentThread();
        //获取此线程中维护的ThreadLocalMap 
        ThreadLocalMap map = getMap(t);
        if (map != null)
            //如果mapo不为空，设置值，注意this为当前调用set方法的threadlocal对象
            map.set(this, value);
        else
            //当前线程不存在ThreadLocalMap ，则调用createMap进行ThreadLocalMap 的初始化
            //并将当前线程t和value作为第一个Entry存放至ThreadLocalMap 中
            createMap(t, value);
    }

//获取当前线程Thread对应的ThreadLocalMap
ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

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

总结一下set方法：

1. 首先获取当前线程，并根据当前线程获取到该线程维护的ThreadLocalMap
2. 如果map不为空，则以threadlocal为空，将value值set进map
3. 如果map为空，则给该线程创建map，并设置初始值

get

 public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            //以当前threadlocal为key，获取对应的存储实体Entry
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                //如果e不为空，获取存储的value
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        //初始化：有2种情况
        //1）map不存在，表示此线程没有维护的ThreadLocalMap
        //2）map存在，但是没有与当前threadlocal关联的entry
        return setInitialValue();
    }

//初始化
private T setInitialValue() {
        //调用该方法获取初始化的值
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            //存在则设置值
            map.set(this, value);
        else
            //当前线程不存在ThreadLocalMap，则对ThreadLocalMap 进行初始化，set方法中有分析
            createMap(t, value);
        //返回设置的value
        return value;
    }

//此方法可以被子类重写，通常采用匿名内部内的方式实现。
//返回当前线程对应的threadlocal的初始值。
//此方法的第一次调用发生在当线程通过get方法访问此线程的threadlocal值时,
//且当前线程未调用set方法，通常情况下，每个线程最多调用一次该方法
 protected T initialValue() {
        return null;
    }

通过对get方法的分析可得到：如果在set之前执行get方法，则会返回默认值null，如果想改变该默认值，可通过子类去重写

总结一下get方法：

1. 首先获取当前线程，并根据当前线程获取到该线程维护的ThreadLocalMap
2. 如果map不为空，则在map中以threadlocal为key获取对应的entry，map如果为空，则4
3. 如果entry不为空，则返回entry.value,否则4
4. map为空或者entry为空，则通过initialValue获取最初的默认值value，然后使用threadlocal和value作为第一个entry去创建map

remove

//删除当前线程中保存的threadlocal对应的实体entry
public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             //以当前threadlocal为空删除对应的实体entry
             m.remove(this);
     }

ThreadLocalMap源码分析

先分析一些简单的方法和属性： 

static class ThreadLocalMap {
 
    /**    
         * 自定义一个Entry类，并继承自弱引用
         * 用来保存ThreadLocal和Value之间的对应关系
         *
         * 之所以用弱引用，是为了解决线程与ThreadLocal之间的强绑定关系
         * 会导致如果线程没有被回收，则GC便一直无法回收这部分内容
         */
    static class Entry extends WeakReference> {
        Object value;
 
        Entry(ThreadLocal k, Object v) {
            super(k);
            value = v;
        }
    }
    
    /**
         * The initial capacity -- MUST be a power of two.
         * Entry数组的初始化大小，必须是2的幂
         */
    private static final int INITIAL_CAPACITY = 16;
 
    /**
         * The table, resized as necessary.
         * table.length MUST always be a power of two.
         * 数组
         * 长度必须是2的N次幂
         * 这个可以参考为什么HashMap里维护的数组也必须是2的N次幂
         * 主要是为了减少碰撞，能够让保存的元素尽量的分散
         * 关键代码还是hashcode & table.length - 1  前面的博文都有分析
         */
    private Entry[] table;
 
    /**
         * The number of entries in the table.
         * table里的元素个数
         */
    private int size = 0;
 
    /**
         * The next size value at which to resize.
         * 扩容的阈值
         */
    private int threshold; // Default to 0
 
    /**
         * Set the resize threshold to maintain at worst a 2/3 load factor.
         * 根据长度计算扩容的阈值
         */
    private void setThreshold(int len) {
        threshold = len * 2 / 3;
    }
 
    /**
     * 通过以下两个获取next和prev的代码可以看出，entry数组实际上是一个环形结构
     */
    /**
      * Increment i modulo len.
      * 获取下一个索引，超出长度则返回0
      */
    private static int nextIndex(int i, int len) {
        return ((i + 1 < len) ? i + 1 : 0);
    }
 
    /**
     * Decrement i modulo len.
     * 返回上一个索引，如果-1为负数，返回长度-1的索引
     */
    private static int prevIndex(int i, int len) {
        return ((i - 1 >= 0) ? i - 1 : len - 1);
    }
 
    /**
     * 构造一个包含firstKey和firstValue的map。
     * ThreadLocalMap是惰性构造的，所以只有当至少要往里面放一个元素的时候才会构建它。
     */
    ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
        // 初始化table的大小为16
        table = new Entry[INITIAL_CAPACITY];
        // 通过hashcode & （长度-1）的位运算，确定键值对的位置
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        // 创建一个新节点保存在table当中
        table[i] = new Entry(firstKey, firstValue);
        // 设置table内元素为1
        size = 1;
        // 设置扩容阈值
        setThreshold(INITIAL_CAPACITY);
    }
 
    /**       
         * ThreadLocal本身是线程隔离的，按道理是不会出现数据共享和传递的行为的
         * 这是InheritableThreadLocal提供了了一种父子间数据共享的机制
         * @param parentMap the map associated with parent thread.
         */
    private ThreadLocalMap(ThreadLocalMap parentMap) {
        Entry[] parentTable = parentMap.table;
        int len = parentTable.length;
        setThreshold(len);
        table = new Entry[len];
 
        for (int j = 0; j < len; j++) {
            Entry e = parentTable[j];
            if (e != null) {
                @SuppressWarnings("unchecked")
                ThreadLocal