ThreadLocal原理

先看一下大体结构

ThreadLocal（线程本地变量），作用是让每个线程都维护一份独立的变量副本，解决了变量并发访问冲突的问题。表面上看，变量是存储在ThreadLocal里面的，实则不然：
1. ThreadLocal只是个“工具类”，对外暴露了get、set、remove接口；
2. 内部实现：变量其实是保存在当前线程Thread类里，准确来说是保存在Thread类中由ThreadLocal实现的ThreadLocal.ThreadLocalMap成员变量里；

先易后难，先看入口方法

set

public void set(T value) {
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 尝试获取当前线程内部的ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    // map不为空，就正常set值
    if (map != null)
        map.set(this, value);
    else
        // 否则就初始化Map
        createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
    // 可以看出，ThreadLocalMap是存储在线程对象里的
    return t.threadLocals;
}

void createMap(Thread t, T firstValue) {
    // new个ThreadLocalMap，key和value分别为当前ThreadLocal对象已经传入的值
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

get

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    // 如果map不为空，就尝试获取；
    if (map != null) {
        // 以当前ThreadLocal对象为key，获取对应的值
        ThreadLocalMap.Entry e = map.getEntry(this);
        // 不为空就返回，否则返回默认值
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 否则初始化并返回默认值
    return setInitialValue();
}

private T setInitialValue() {
    // 获得默认值
    T value = initialValue();
    // 以下过程和set方法一样
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}
// 这里可以看出，这个方法可以由子类实现，默认返回null
protected T initialValue() {
    return null;
}

remove

public void remove() {
    // 尝试获取ThreadLocalMap
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        // map不为空，则移除key为当前ThreadLocal对象的Entry
        m.remove(this);
}

小结论：ThreadLocalMap存储在Thread对象里，但却是在ThreadLocal对象里进行初始化，ThreadLocal对外暴露的接口实际上都是交给ThreadLocalMap进行处理，所以ThreadLocalMap是核心部分。

=======================================================

ThreadLocalMap里有个Entry对象

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** 和当前ThreadLocal有关联的值 */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

这个Entry是弱引用的，扩展一下：

强引用：在代码里普遍存在，比如Object obj = new Object();。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误使程序异常终止，也不会靠随意回收具有"强引用"的对象来解决内存不足问题。

软引用：如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。软引用可用来实现内存敏感的高速缓存。

弱引用：被弱引用关联的对象只能生存到下一次垃圾收集发生之前。在垃圾回收过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。

虚引用：如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。虚引用主要用来跟踪对象被垃圾回收的活动。也就是说，持有虚引用的对象能在这个对象被回收时收到一个系统通知。

既然是弱引用，那么就会有个问题：如果key被回收了，就存在一个null-value键值对，这个value既无法被访问到，同时如果线程生命周期很长（比如线程池里），那么这些null key的强引用关系：Thread --> ThreadLocalMap-->Entry-->Value导致Value不会回收，造成内存泄漏。

官方团队也加入了解决办法，当调用set、get、remove方法的时候会去扫描key为null的Entry并清除（Entry=null）。但是这个并不是100%保证不出问题，如果这个Entry过期了，但是线程没有调用set、get或者remove，这个null key的Entry依然会存在，依然是内存泄漏了。所以还是要规范，不用了就调用remove清除。

一个例子就是线程池使用ThreadLocal

import java.util.*;
import java.util.concurrent.*;

public class Main {
    private static ThreadLocal<Integer> local = new ThreadLocal<>();

    public static void main(String[] args) throws Exception {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 3, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));
        for (int i = 0; i < 10; i++){
            executor.execute(()->{
                String name = Thread.currentThread().getName();
                // 正常来说，每个线程先读取得到的值应该是一样的初始值（同一变量的副本）。如果读到了其它线程修改之后的值，则证明出问题了。
                Integer init = local.get();
                // 修改自己变量的值
                local.set(new Random().nextInt(100));
                // 读取修改之后的值
                Integer data = local.get();
                System.out.println(name + " | init:" + init + " | data:" + data);
            });
        }
        executor.shutdown();
    }
}

输出：（结果显而易见，由于没有清理自己的变量，导致当前线程复用到其它任务的时候，仍然保留着上一家的数据，如果先读取就会出错）

pool-1-thread-3 | init:null | data:84
pool-1-thread-1 | init:null | data:33
pool-1-thread-2 | init:null | data:85
pool-1-thread-1 | init:33 | data:96
pool-1-thread-3 | init:84 | data:82
pool-1-thread-1 | init:96 | data:83
pool-1-thread-2 | init:85 | data:51
pool-1-thread-1 | init:83 | data:48
pool-1-thread-3 | init:82 | data:17
pool-1-thread-2 | init:51 | data:58

正确做法

import java.util.*;
import java.util.concurrent.*;

public class Main {
    private static ThreadLocal<Integer> local = new ThreadLocal<>();

    public static void main(String[] args) throws Exception {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 3, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));
        for (int i = 0; i < 10; i++){
            executor.execute(()->{
                try {
                    String name = Thread.currentThread().getName();
                    // 正常来说，每个线程先读取得到的值应该是一样的初始值（同一变量的副本）。如果读到了其它线程修改之后的值，则证明出问题了。
                    Integer init = local.get();
                    // 修改自己变量的值
                    local.set(new Random().nextInt(100));
                    // 读取修改之后的值
                    Integer data = local.get();
                    System.out.println(name + " | init:" + init + " | data:" + data);
                } finally {
                    // 最终清除数据
                    local.remove();
                }
            });
        }
        executor.shutdown();
    }
}

输出：

pool-1-thread-1 | init:null | data:6
pool-1-thread-1 | init:null | data:93
pool-1-thread-2 | init:null | data:93
pool-1-thread-3 | init:null | data:41
pool-1-thread-2 | init:null | data:37
pool-1-thread-1 | init:null | data:54
pool-1-thread-2 | init:null | data:61
pool-1-thread-3 | init:null | data:76
pool-1-thread-2 | init:null | data:95
pool-1-thread-1 | init:null | data:68

所以，千万记得remove啊

源码

private final int threadLocalHashCode = nextHashCode();
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);  // HASH_INCREMENT = 0x61c88647
}

0x61c88647是斐波那契散列乘数，它的优点是通过它散列(hash)出来的结果分布会比较均匀，可以很大程度上避免hash冲突。

set

private void set(ThreadLocal<?> key, Object value) {
    // 指向当前数组
    Entry[] tab = table;
    // 当前数组长度
    int len = tab.length;
    // 计算下标
    int i = key.threadLocalHashCode & (len-1);

    // 遍历table
    for (Entry e = tab[i];  // 从计算的下标开始
         e != null; // 直到遇到空槽
         e = tab[i = nextIndex(i, len)]) {  // 指向下一个位置的元素
        // 获取当前位置的key
        ThreadLocal<?> k = e.get();

        // 如果传入的key已存在，则覆盖旧值
        if (k == key) {
            e.value = value;
            return;
        }
        // 如果当前位置i的key为null，
        if (k == null) {
            // 此方法：1. 用指定key-value的新Entry替换set操作期间遇到的过期Entry（key==null）2. 如果遇到已存在的key，则用新值覆盖旧值。3. 清除两个空槽之间过期的Entry
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    // 如果前面没找到已存在的key，则新创建一个Entry放在此位置
    tab[i] = new Entry(key, value);
    int sz = ++size;
    // 1. 启发式地扫描并清除过期的Entry。2. 如果没有需要清除的并且需要扩容，则进行扩容
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

set方法做的事情：从计算得到的下标开始，遇到空槽为止进行扫描。遇到相同的key则覆盖；遇到key为null的Entry则直接new一个新Entry替换无效Entry；否则在下标处new一个新的Entry。最后扫描并清理无效槽位，如果满足扩容条件即扩容。

已经确认，只有set的时候可能调用replaceStaleEntry方法，而这种情况下当前位置i(staleSolt)是个过期位置（key==null）

private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) {
    // 指向当前table
    Entry[] tab = table;
    // table长度
    int len = tab.length;
    // 指向每一个遍历的数组对象
    Entry e;

    // 记录需要删除的槽位。开始的时候等于传入的位置。
    int slotToExpunge = staleSlot;
    // 向前找直到槽位为空，如果遇到key为空的Entry，则仅仅记录下最后一个。
    for (int i = prevIndex(staleSlot, len); // 找到当前位置的前一位：((i - 1 >= 0) ? i - 1 : len - 1)
         (e = tab[i]) != null;  // 结束条件是当前位置为null（空槽）
         i = prevIndex(i, len)) // 继续寻找前一位
        if (e.get() == null)
            // 如果当前位置的key是null，则记录下此位置
            slotToExpunge = i;

    // 查找key或者空槽，以最先出现的为准
    for (int i = nextIndex(staleSlot, len); // 当前位置的下一个开始：((i + 1 < len) ? i + 1 : 0)
         (e = tab[i]) != null;      // 遇到空槽结束
         i = nextIndex(i, len)) {   // 下一个
        // 当前key
        ThreadLocal<?> k = e.get();

        // 如果当前key和传入的key相同，那么我们需要将它与过期槽位的内容进行交换，以保持哈希表的顺序。
        // 然后可以将新过期的槽或上面遇到的任何其他过期槽的位置发送到expungeStaleEntry，以删除或重新散列运行中的所有其他Entry。
        if (k == key) {
            e.value = value;
            // 当前位置
            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;

            // 如果slotToExpunge == staleSlot，则证明上一步向前找的过程中没有遇到key==null的Entry。此种情况，把slotToExpunge记录为当前位置i
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        // 1. 当前key为null，则此位置是个过期Entry
        // 2. 如果此时slotToExpunge == staleSlot，则证明上一步向前找的过程中没有遇到key==null的Entry、并且向后找的过程也没有遇到相同的key（因为前面如果遇到了相同key，则已经退出了循环）
        // 满足两个条件，则将当前过期槽位的位置记录下来
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // 如果相同的key没有找到，则把新的Entry放在过期的槽位
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);

    // 如果还存在其它过期槽位，删除之
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

图解

情况示例一：向前寻找有个过期槽位，向后寻找没有冲突key。

情况示例二： 向前寻找有个过期槽位，向后寻找发现冲突key。

.

再来看expungeStaleEntry，顾名思义，删除过期的Entry。

// 在staleSlot和下一个空槽之间：1. 重新哈希任何可能碰撞的Entry。2. 删除过期的Entry。
private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;

    // 删除位于staleSlot的Entry
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;

    // Rehash 直到遇到空槽
    Entry e;
    int i;
    // 从staleSlot的下一个开始遍历
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        // 当前槽位的key
        ThreadLocal<?> k = e.get();
        // key为null，删除之
        if (k == null) {
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            // rehash
            int h = k.threadLocalHashCode & (len - 1);
            // 如果新计算出的位置不等于当前位置，则：
            if (h != i) {
                // 1. 先把当前位置置为空
                tab[i] = null;

                // Unlike Knuth 6.4 Algorithm R, we must scan until
                // null because multiple entries could have been stale.
                // 2. 从h开始找直到遇到空槽。然后把其中的内容移到找到的空槽里。
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    // 返回空槽的位置
    return i;
}

图解

看cleanSomeSlots

// 启发式地扫描并清除过期的Entry。
private boolean cleanSomeSlots(int i, int n) {
    boolean removed = false;
    Entry[] tab = table;
    int len = tab.length;
    do {
        // 从位置i的下一个开始搜索
        i = nextIndex(i, len);
        Entry e = tab[i];
        // 如果遇到过期Entry，清除
        if (e != null && e.get() == null) {
            n = len;
            removed = true;
            i = expungeStaleEntry(i);
        }
    } while ( (n >>>= 1) != 0);
    // 只要有过期Entry被移除就会返回true
    return removed;
}

.

最后看下扩容

private void rehash() {
    // 这个方法从0开始遍历table，遇到key==null的就执行expungeStaleEntry方法
    expungeStaleEntries();

    // Use lower threshold for doubling to avoid hysteresis
    if (size >= threshold - threshold / 4)
        // 如果当前size达到扩容阈值的75%，则扩容
        resize();
}

private void resize() {
    // 旧table
    Entry[] oldTab = table;
    // 旧容量
    int oldLen = oldTab.length;
    // 新容量=旧容量*2（旧容量的2倍）
    int newLen = oldLen * 2;
    // 按照新容量new个新的Entry数组
    Entry[] newTab = new Entry[newLen];
    int count = 0;

    // 遍历旧table
    for (int j = 0; j < oldLen; ++j) {
        Entry e = oldTab[j];
        if (e != null) {
            ThreadLocal<?> k = e.get();
            // 遇到过期Entry，处理之
            if (k == null) {
                e.value = null; // Help the GC
            } else {
                // 正常的Entry做Rehash操作，放到计算得到的新位置h之后的第一个空槽里
                int h = k.threadLocalHashCode & (newLen - 1);
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                count++;
            }
        }
    }

    // 设置新的阈值
    setThreshold(newLen);
    size = count;
    table = newTab;
}

扩容很简单：达到扩容阈值的75%，即扩容，新容量是老容量的2倍，遇到过期的Entry删除，其它Entry做Rehash操作放到新位置。

以上是set核心方法，下面来看get涉及的方法getEntry

private Entry getEntry(ThreadLocal<?> key) {
    // 计算下标
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    // 有值则返回
    if (e != null && e.get() == key)
        return e;
    else
        // 没有匹配的则进行清理工作（这个方法也体现了，调用get方法不一定会进行清理过期Entry工作）
        return getEntryAfterMiss(key, i, e);
}

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;

    // 从给定的位置i开始遍历
    while (e != null) {
        ThreadLocal<?> k = e.get();
        // 如果key的地址相同，证明不需要清理，直接返回即可
        if (k == key)
            return e;
        // 如果key是null，则清理
        if (k == null)
            expungeStaleEntry(i);
        else
            // 否则移到下一个
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

最后是remove

private void remove(ThreadLocal<?> key) {
    // 当前table
    Entry[] tab = table;
    // 当前长度
    int len = tab.length;
    // 根据key计算下标
    int i = key.threadLocalHashCode & (len-1);
    // 从计算得到的位置开始清理，直到遇到空槽停止
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        // 如果找到目标key，清理后返回
        if (e.get() == key) {
            e.clear();
            expungeStaleEntry(i);
            return;
        }
    }
}

最后两个问题（我在读的过程中也充满了疑惑）

源码里replaceStaleEntry有个向前找向后找的过程，如果循环之内的条件一直不满足，则只能依靠循环条件（(e = tab[i]) != null）来结束循环；

类似的expungeStaleEntry中Rehash过程有个寻找新位置的过程，结束条件也是while (tab[h] != null)。

我就想了，如果没有空槽呢？岂不是死循环了。

而实际上是不会存在这种情况的，因为扩容啊，每次达到扩容阈值的75%就扩容了，所以空槽是肯定一直存在的。

我们了解到底层的Map是一个Entry数组，那么问题来了：通常我们使用ThreadLocal都是存储当前线程的私有变量，也就是只存一个值，为什么还需要一个可以存多个值的Entry数组呢？

ThreadLocal可以定义多个，每个都有自己的线程私有变量。