ThreadLocal底层原理

ThreadLocal

作用

线程并发:应用于多线程并发场景

传递数据:用于不同组件传递公共变量

线程隔离:各线程独立,互不影响

常用方法

ThreadLocal() 构造器
set(T value) 设置存入变量
get() 获取变量
remove() 移除变量

与Synchronized的区别

Synchronized

原理
同步机制采用"以时间换空间"的方式,只提供一份变量,多个线程排队访问
侧重点
多线程之间访问资源的同步

ThreadLocal

原理
ThreadLocal采用"以空间换时间"的方式,为每个线程提供一份变量副本,以实现同时访问而互不干扰
侧重点
多线程之间数据相互隔离

内部结构

早期设计

在ThreadLocal里创建一个Map,使用当前线程作为key,要存储的变量作为value,以实现多线程数据隔离

如今设计

实现

​ 在每个线程里面创建一个Map(ThreadLocalMap),以ThreadLocal作为key,以变量副本作为value,由ThreadLocal来维护这个Map,负责向Map里添加和获取变量值,不同线程只能获取自身的变量副本,以此实现线程隔离

好处

1.减少了Map集合中的Entry数量
2.当线程结束时,ThreadLocalMap也会同时被销毁,减少内存的使用(早期设计的Map存在于ThreadLocal里面,当线程结束的时候,Map不会被销毁)

方法源码

initialValue()

protected T initialValue() {
        return null;
    }

get()

    public T get() {
        //获取当前线程
        Thread t = Thread.currentThread();
        //获取Map集合(当前线程的threadLocals属性)
        ThreadLocalMap map = getMap(t);
        //判空
        if (map != null) {
            //获取key为ThreadLocal的Entry
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                //返回结果
                return result;
            }
        }
        /*如果map为null,或者获取到的Entry为null,执行此方法,创建map,或为key为ThtreadLocal的Entry赋初始值*/
        return setInitialValue();
    }

getMap()

    ThreadLocalMap getMap(Thread t) {
        /*获取当前线程的threadLocals属性,类型为ThreadLocalMap*/
        return t.threadLocals;
    }

remove()

     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null) {
             m.remove(this);
         }
     }

set(T value)

public void set(T value) {
    //获取当前线程
    Thread t = Thread.currentThread();
    //获取Map集合(当前线程的threadLocals属性)
    ThreadLocalMap map = getMap(t);
    //判空
    if (map != null) {
        //以ThreadLocal为key,向map集合里插入数据
        map.set(this, value);
    } else {
        //map为null,创建map
        createMap(t, value);
    }
}

map.set()

    private void set(ThreadLocal<?> key, Object value) {

        //获取Entry数组
        Entry[] tab = table;
        //获取数组长度
        int len = tab.length;
        //计算索引(解决hash冲突核心)
        int i = key.threadLocalHashCode & (len-1);

        //使用线性探测法查找Entry
        for (Entry e = tab[i];
             e != null;
             e = tab[i = nextIndex(i, len)]) {
             //获取当前遍历到的Entry的key
            ThreadLocal<?> k = e.get();

            //若key相等,则覆盖
            if (k == key) {
                e.value = value;
                return;
            }

            //若遍历到的key为null,用新元素替代旧元素
            if (k == null) {
                replaceStaleEntry(key, value, i);
                return;
            }
        }

        //新建一个Entry,添加到数组中
        tab[i] = new Entry(key, value);
        int sz = ++size;
        /*清理key为null的元素,若没有key为null的元素被清理,且元素个数达到阈值,对集合进行全面清理,并根据清理后是否仍然达到阈值决定是否需要扩容(默认扩容为原来的2倍)*/
        if (!cleanSomeSlots(i, sz) && sz >= threshold)
            rehash();
    }

nextindex()

    //获取环形数组的下一个索引
    private static int nextIndex(int i, int len) {
        return ((i + 1 < len) ? i + 1 : 0);
    }

createMap()

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

ThreadLocalMap基本结构

简介

ThreadLocalMap是ThreadLocal的内部类,没有实现Map接口,而是独立实现了Map集合的功能,其内部类Entry同样是独立实现的

Entry

Entry类继承自弱引用WeakReference,并使用且只能用ThreadLocal作为key,对ThreadLocal的引用为弱引用,其目的在于将ThreadLocal的生命周期与Thread的生命周期解绑,当key为null时,表示该Entry可以被删除

成员变量

    //map的初始容量,必须是2的整次幂
    private static final int INITIAL_CAPACITY = 16;

    //存放Entry的数组,大小同样必须是2的整次幂
    private Entry[] table;

    //集合的大小,即集合中的Entry个数
    private int size = 0;

    //集合扩容阈值,用于判断集合是否需要扩容
    private int threshold;

hash冲突的解决

ThreadLocalMap的构造方法

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    table = new Entry[INITIAL_CAPACITY];
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    setThreshold(INITIAL_CAPACITY);
}

核心代码

/*计算索引,&(INITIAL_CAPACITY - 1)是取余运算的更高效实现方式,依赖于容量值为2的整次幂*/
 int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);

//计算hash值
private final int threadLocalHashCode = nextHashCode();

/*HASH_INCREMENT=0x61c88647,与斐波拉契数列(黄金分割数)有关,其目的是使hash值均匀地分布在大小为2的n次幂的数组中,尽量避免hash冲突*/
 private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

/*AtomicInteger是一个提供原子操作的Integer类,使用线程安全的方式操作加减,适合高并发的情况下使用*/
private static AtomicInteger nextHashCode = new AtomicInteger();

原理

ThreadLocalMap是使用线性探测法来解决hash冲突的,通过key(ThreadLocal)的hash值和容量减一进行与操作得到索引,从该索引开始循环查找Entry数组(table)中key为null的元素位置,若探测到数组最后一个元素,则下一个元素为数组第一个元素,亦即下一个索引为0,若key在数组中已经存在,则直接覆盖key对应的value,若遇到key为null的元素,则使用当前key和value替换该位置的旧元素,若以上两种情况未发生,则一直遍历到一个为null的Entry,将当前的key和value封装为Entry存进去

内存泄漏问题

ThreadLoca的内存泄漏问题与Entry与key之间的弱引用无关

若Entry与key使用强引用

当ThreadLocal使用完毕,其引用被销毁,且没有手动删除此key对应的Entry以及当前线程仍未结束的情况下,ThreadLocal始终与Entry存在强引用,又因为Thread->ThreadLocalMap->Entry强引用链的存在,导致ThreadLocal无法被垃圾回收器回收,造成内存泄漏

若Entry与key使用弱引用

当ThreadLocal使用完毕,其引用被销毁,且没有手动删除此key对应的Entry以及当前线程仍未结束的情况下,ThreadLocal始终与Entry之间为引用,那么下一次垃圾回收就会将ThreadLocal回收掉,但因为Thread->ThreadLocalMap->Entry强引用链的存在,导致ThreadLocal对应的Entry虽然key为null,但仍无法被垃圾回收器回收,造成内存泄漏

为何使用弱引用?

其实只要在使用完ThreadLocal后记得记事remove,不管是强引用还是弱引用都不会存在内存泄漏问题,而相较于弱引用,强引用方式更加不好控制,如使用线程池的时候,线程是不会被销毁的,且在ThreadLocalMap的set()/getEntry()方法中其实对key为null的Entry做了判断,将其置为null,故使用弱引用比强引用多了一层保障,即使没有手动removeEntry,也会在下一次调用get,set,remove之一的时候自动删除该Entry,避免内存泄漏