ThreadLocal原理

一、什么是ThreadLocal

　　ThreadLocal是线程内的局部变量，仅在线程的生命周期内起作用。变量值在线程间不可见。

二、ThreadLocal的使用

　　ThreadLocal使用详情如下：

import java.util.concurrent.CountDownLatch;

public class TestThreadLocal {
    public static void main(String[] args) {
        ThreadLocal th = new ThreadLocal();
        th.set(Thread.currentThread().getName());
        CountDownLatch countDownLatch = new CountDownLatch(3);
        for (int i = 0; i < 3; i++) {
            // 子线程
            new Thread(() -> {
                try{
                    if (th.get() == null) {
                        th.set("current Thread Name：" + Thread.currentThread().getName());
                    }
                }finally {
                    System.out.println(th.get());
                    countDownLatch.countDown();
                }
            }).start();

        }
        // 主线程
        System.out.println("current Thread Name：" + th.get());
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

三、ThreadLocal原理

 

　　Thread中持有ThreadLocal.ThreadLocalMap容器存储线程变量，每个线程都有属于自己的ThreadLocal.ThreadLocalMap，当获取线程变量时，优先从当前的Thread中获取ThreadLocal.ThreadLocalMap，若容器不为空，则将ThreadLocal作为key，变量值作为value设置到ThreadLocal.ThreadLocalMap中，若ThreadLocal.ThreadLocalMap为空，则优先创建ThreadLocal.ThreadLocalMap对象，通过构造函数初始化ThreadLocalMap的属性。

　　ThreadLocal的set/get方法，实际上调用的ThreadLocalMap的set/get方法。ThreadLocalMap内部维护Entry对象数组，数组初始容量、扩容阀值，同时拥有扩容resize()和清理无效数据expungsStaleEntries()的方法避免内存泄露。

　　Entry对象用来存储ThrealLocal与变量值Value，key为ThrealLocal，Value为设置的变量值。

四、ThreadLocal源码分析

　　ThreadLocal主要内部信息如下：

 

　　ThreadLocal中ThreadLocalMap作为容器存储线程变量，set()、get()、remove()为添加、获取、删除线程变量的方法。

4.1、容器 - ThreadLocalMap

　　ThreadLocalMap是ThreadLocal静态内部类，是一个类似HashMap的容器，用于存储线程变量，key作为线程的引用，value作为线程变量的值。

  

　　ThreadLocalMap与HashMap类似，持有Entry数组来保存线程及变量值，默认数组的初始大小16，阀值为数组初始值的三分之二，默认阀值10，超过此阀值，Entry数组可进行扩容操作。

　　ThreadLocalMap中提供删除过期数据的方法，防止内存泄露。

1、Entry

　　Entry的类图结构如下：

 

　　Java中常见的引用类型：强、软、弱、虚。弱引用 java.lang.ref.WeakReference 来表示。弱引用类型，当JVM发生gc时，会回收弱引用对象占用的空间，防止内存泄露。

Reference是所有引用对象的基类，定义了应用对象的基本操作。 

 

　　Entry是弱引用类型，将当前线程的引用作为key，线程变量值作为value。Entry通过get()方法获取当前线程的ThreadLocal对象，若获取到的ThreadLocal为空，那么Entry对象会从Entry数组中移除。

static class Entry extends WeakReference<ThreadLocal<?>> {
    // ThreadLocal中存储的变量值
    Object value;
    
    // 构造函数
    Entry(ThreadLocal<?> k, Object v) {
        // 当前线程，设置到父类Reference的 referent 属性
        super(k);
        // 线程变量值
        value = v;
    }
}

　　Entry对象用来存储 ThreadLocal对象、线程变量值。

2、ThreadLocalMap构造函数

　　ThreadLocalMap中Entry数组，用来存储线程与变量值，与HashMap的类似，ThreadLocalMap的阀值为Entry数组大小的三分之二，用来做Entry数组是否需要扩容的判断。对ThreadLocal的hashCode值进行位运算获取Entry数组的下标。

// 线程变量持有对象集合，可做扩容处理
private Entry[] table;
// 集合初始化大小
private static final int INITIAL_CAPACITY = 16;
// Entry在数组中的数量
private int size = 0;
// 负载因子，为数组容量的 三分之二，用来做扩容判断
private int threshold;

// 构造函数
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    // 初始化Entry数组
    table = new Entry[INITIAL_CAPACITY];
    // 位运算获取数组下标
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    // 创建持有当前线程、变量值的Entry对象设置进数组中
    table[i] = new Entry(firstKey, firstValue);
    // Entry在数组中的数量
    size = 1;
    // 设置负载因子，为 INITIAL_CAPACITY 的 三分之二
    setThreshold(INITIAL_CAPACITY);
}

// 初始化
private void setThreshold(int len) {
    threshold = len * 2 / 3;
}

3、扩容处理

　　ThreadLocalMap的Entry数组，扩容后的容量是原来的2倍。在扩容前，先清理Entry数组中所有无效的Entry对象，清理完成后，再判断Entry数组中的Entry元素数量是否达到或超过阀值的四分之三，满足此条件，数组才会做扩容处理。

　　在扩容阶段，如果出现hash冲突，会沿着当前下标往数组后面寻找Entry元素为null的地址，将Entry元素设置到该地址中，这种方式也叫作线性探测寻址法。

当Entry数组中的Entry对象达到或超出了设置的阀值，需要对ThreadLocalMap的Entry[]做扩容处理，ThreadLocalMap#rehash() 方法：

// 扩容处理
private void rehash() {
    // 清理Entry数组中无效的Entry对象，
    expungeStaleEntries();

    // Entry数组中的有效Entry对象 大于等于  阀值的四分之三 ，做扩容处理
    if (size >= threshold - threshold / 4)
        resize();
}

// 清除Entry数组中所有被删除的Entry对象(Entry对象的Refrent引用为null))
private void expungeStaleEntries() {
    Entry[] tab = table;
    int len = tab.length;
    // 遍历数组
    for (int j = 0; j < len; j++) {
        Entry e = tab[j];
        // Entry对象的Refrent引用为null
        if (e != null && e.get() == null)
            // 清除元素
            expungeStaleEntry(j);
    }
}

// 扩容处理
private void resize() {
    // 原Entry数组
    Entry[] oldTab = table;
    // 原Entry数组长度
    int oldLen = oldTab.length;
    // 新Entry数组长度
    int newLen = oldLen * 2;
    // 创建新的Entry数组
    Entry[] newTab = new Entry[newLen];
    // 统计有效的Entry对象
    int count = 0;
    
    // 遍历原Entry数组
    for (int j = 0; j < oldLen; ++j) {
        // 获取Entry对象
        Entry e = oldTab[j];
        // Entry对象不为null
        if (e != null) {
            // 获取Entry的refrent
            ThreadLocal<?> k = e.get();
            if (k == null) {
                // 有助于gc清理
                e.value = null;
            // Entry设置到新数组
            } else {
                // 计算原Entry数组元素在新Entry数组中的下标
                int h = k.threadLocalHashCode & (newLen - 1);
                // hash冲突的处理，线性探测地址法
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                // 添加Entry元素到新数组
                newTab[h] = e;
                // Entry元素数量 + 1
                count++;
            }
        }
    }
    
    // 设置扩容后的阀值
    setThreshold(newLen);
    // 设置有效Entry元素的个数
    size = count;
    // 设置Entry数组
    table = newTab;
}

4.2、设置线程变量 - set源码分析

　　首次调用ThreadLocal的set方法设置线程变量值，执行createMap方法创建ThreadLocalMap对象，通过有参构造方法传递当前线程引用、变量值，存储到ThreadLocalMap中。实际上是存储在ThreadLocalMap的Entry数组中。不是首次调用ThreadLocal的set方法，获取ThreadLocalMap对象，通过ThreadLocalMap的set方法将线程引用与变量值设置到ThreadLocalMap中。

　　ThreadLocal线程变量添加值，ThreadLocal#set() 核心代码：

// 存储当前线程与变量值的映射
ThreadLocal.ThreadLocalMap threadLocals = null;

public void set(T value) {
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 获取线程与变量值映射容器
    ThreadLocalMap map = getMap(t);
    // 容器已存在，添加
    if (map != null)
        map.set(this, value);
    // 首次设置线程变量值，容器不存在，创建容器存储线程与变量值的映射
    else
        createMap(t, value);
}

// 获取与ThreadLocal关联的Map
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

// 创建Map容器
void createMap(Thread t, T firstValue) {
    // ThreadLocalMap存储当线程与变量值映射
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

　　设置线程变量实际调用的是ThreadLocalMap的set()方法，ThreadLocalMap#set() 核心代码：

private void set(ThreadLocal<?> key, Object value) {
    // 获取Entry数组
    Entry[] tab = table;
    // 获取当前数组长度
    int len = tab.length;
    // 根据线程引用获取数组下标
    int i = key.threadLocalHashCode & (len-1);
    
    // 线性探测地址法 解决hash冲突
    // 当前key在数组中是否存在
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
             
        // 获取Entry对象的线程引用
        ThreadLocal<?> k = e.get();
        // 当前线程在数组中的引用存在，重新设置变量值
        if (k == key) {
            e.value = value;
            return;
        }
        // Entry中持有的线程引用为空，从数组中删除此Entry对象
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    
    // 将线程、变量值的映射设置到Entry对象中
    tab[i] = new Entry(key, value);
    // 数组中Entry对象的数量 + 1
    int sz = ++size;
    // 清除了数组中的某些元素 并且 当前Entry数组中的Entry对象的数量 大于等于 阀值
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        // 扩容处理
        rehash();
}

　　ThreadLocal采用线性探测的开放地址法去解决 hash 冲突。与HashMap的链地址法不同，ThreadLocal不会将hash冲突的数据放在链表上。当ThreadLocal 的 key 存在 hash 冲突，会线性地往后探测直到找到为 null 的位置存入对象，或者找到 key 相同的位置覆盖更新原来的对象。在这过程中若发现不为空但 key 为 null 的桶（key 过期的 Entry 数据）则启动探测式清理操作。

4.3、获取线程变量 - get源码分析

　　根据ThreadLocal实例对象，获取当前线程的ThreadLocal.ThreadLocalMap中的Entry，若ThreadLocalMap不为空并且Entry不为空，返回Entry对象中的线程变量值Value；若Entry为空或者ThreadLocalMap为空，执行setInitialValue，初始化线程变量值，返回null。

　　返回当前线程的线程变量值，ThreadLocal#get() 核心代码：

ThreadLocal.ThreadLocalMap threadLocals = null;

public T get() {
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 获取当前Thread的 threadLocals 对象
    ThreadLocalMap map = getMap(t);
    // threadLocals不为null
    if (map != null) {
        // ThreadLocal作为key，由于key获取数组下标，获取Entry对象
        ThreadLocalMap.Entry e = map.getEntry(this);
        // Entry不为null
        if (e != null) {
            // 返回ThreadLocal对应的value值
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 可用来替换set()设置初始值，可实现自定义的初始化逻辑
    return setInitialValue();
}

// 设置初始值
private T setInitialValue() {
    // ThreadLocal默认不实现，返回null，由子类实现
    T value = initialValue();
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 获取当前Thread的 ThreadLocal.ThreadLocalMap 对象
    ThreadLocalMap map = getMap(t);
    // threadLocals不为null
    if (map != null)
        // 设置当前线程变量值
        map.set(this, value);
    else
        // 创建Thread的 ThreadLocal.ThreadLocalMap 对象，存储ThreadLocal、value
        createMap(t, value);
    return value;
}

// 初始化线程变量，ThreadLocal不实现，由子类实现
protected T initialValue() {
    return null;
}

// 获取Thread的  ThreadLocal.ThreadLocalMap 对象属性
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

　　ThreadLocal的initialValue方法，默认返回null，可由具体子类实现。主要用于拓展，用户通过此方法可以将自定义内容设置到线程变量中。对于ThreadLocal而言，无论是调用set方法还是get方法，首次设置或获取线程变量，都会初始化当前线程的ThreadLocal.ThreadLocalMap。在ReentrantReadWriteLock中，对读锁的加锁与释放，应用了initialValue方法定义了持有线程重入的次数的对象HoldCounter。

　　获取Entry对象，ThreadLocalMap#getEntry() 核心代码：

// 获取Entry对象
private Entry getEntry(ThreadLocal<?> key) {
    // ThreadLocal的hashCode 与 ThreadLocalMap中Entry数组长度 的 位运算获取数组下标
    int i = key.threadLocalHashCode & (table.length - 1);
    // 获取Entry对象
    Entry e = table[i];
    // Entry不为null，并且Entry中的referent 与 传入的ThreadLocal 引用相同
    if (e != null && e.get() == key)
        // 返回Entry对象
        return e;
    else
        // 通过数组下标获取不到Entry对象的处理
        return getEntryAfterMiss(key, i, e);
}

// 通过ThreadLocal得到的数组下标，在Entry数组中无法获取到线程变量的处理
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    // 获取Entry数组
    Entry[] tab = table;
    // 获取数组长度
    int len = tab.length;
    // 线性探测地址法(Entry数组可能扩容，遍历指定下标的Entry)
    while (e != null) {
        // 获取ThreadLocal对象
        ThreadLocal<?> k = e.get();
        // Entry中的ThreadLocal与传入的ThreadLocal引用相同，返回线程变量值
        if (k == key)
            return e;
        // Entry中的ThreadLocal为空，清理无效数据
        if (k == null)
            expungeStaleEntry(i);
        else
            // 数组下标 + 1
            i = nextIndex(i, len);
        // 重置Entry，循环终止条件
        e = tab[i];
    }
    // 返回null
    return null;
}

// 清理Entry数组中的空闲对象，并重新计算Entry数组中的有效元素的数组下标，将有效Entry对象设置到指定下标
private int expungeStaleEntry(int staleSlot) {
    // 获取Entry数组
    Entry[] tab = table;
    // 获取数组长度
    int len = tab.length;

    // 清理空闲Entry对象
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    // 数组的有效Entry对象减 1
    size--;

    // 重新设置数组下标，循环处理，直到Entry数组中元素为null的为止
    Entry e;
    // 定义数组下标
    int i;
    // 遍历Entry数组
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        // 获取Entry对象
        ThreadLocal<?> k = e.get();
        // Entry对象的refrent为null，即ThreadLocal引用为空
        if (k == null) {
            // 清除过期对象
            e.value = null;
            tab[i] = null;
            size--;
        // Entry对象的refrent不为null
        } else {
            // 重新设置数组中有效Entry的数组下标
            int h = k.threadLocalHashCode & (len - 1);
            // 重新获取的下标 与 原数组下标不一致，用重新获取的下标作为Entry的数组下标
            if (h != i) {
                // 原数组下标的元素置为null
                tab[i] = null;

                // 获取Entry数组中元素为null的下标
                while (tab[h] != null)
                    h = nextIndex(h, len);
                // 设置Entry对象
                tab[h] = e;
            }
        }
    }
    return i;
}

　　getEntry()方法在当前线程的ThreadLocal.ThreadLocalMap不为空时，通过ThreadLocal获取数组下标，从Entry数组中获取对应的Entry对象。若通过数组下标找不到Entry对象，遍历当前下标到数组尾部区间的数组元素，查找匹配的Entry对象，在此过程中会清除无效的Entry对象、重新计算Entry对象数组下标。

4.4、删除线程变量 - remove源码分析

　　线程变量的删除，根据ThreadLocal获取数组下标，获取数组中的Entry对象，将Entry对象的引用属性refrent设置为null，同时执行expungeStaleEntry方法清除Entry数组中无效的元素。

　　ThreadLocal的删除线程变量方法，最终执行ThreadLocalMap#remove()，核心代码：

// 删除ThreadLocal
private void remove(ThreadLocal<?> key) {
    // 获取当前Entry数组
    Entry[] tab = table;
    // 获取当前数组长度
    int len = tab.length;
    // 获取ThreadLocal对应的数组下标
    int i = key.threadLocalHashCode & (len-1);
    // 遍历当前数组下标到数组尾部区间的非null的Entry对象，遇到Entry为null的终止遍历
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        // 匹配到指定的Entry对象
        if (e.get() == key) {
            // Entry对象的引用属性referent设置为null
            e.clear();
            // 清理Entry数组中无效的Entry对象
            expungeStaleEntry(i);
            return;
        }
    }
}

　　Entry的clear方法，实际执行Reference#clear() 核心代码：

public void clear() {
    // 将Entry对象的ThreadLocal对象的引用设置为null
    this.referent = null;
}

　　至此，ThreadLoal的源码分析结束。

五、有关ThreadLocal的面试题

　　ThreadLocal保证的是原子性，每个线程都操作自己的数据，不会去操作临界资源。

5.1、ThreadLocal内存泄露

　　ThreadLocal的内存泄露分为key的内存泄露、value的内存泄露。

1、内存泄露问题

　　若ThreadLocal引用丢失，key是弱引用会被GC回收，如果对应value中的线程没有被回收，会导致内存泄露，内存中的value无法被回收，也无法被获取到。

2、内存泄露解决方案

　　key是ThreadLocal本身，使用弱引用解决内存泄露问题，每次GC都会被回收，会将key置为null；

 

　　value内存泄露的解决方案，Entry[]数组中有remove方法，清理key为null的Entry对象。