ThreadLocal原理解析ThreadLocal ThreadLocal是java.lang包下的一个类，为了解决线

ThreadLocal

ThreadLocal是java.lang包下的一个类，为了解决线程并发时，变量共享的问题；线上上下文透传，例如记录日志的traceId

由于过度设计，比如弱引用和哈希碰撞，导致理解程度难度大，使用成本高，反而成为故障高发点，容易出现内存泄漏、脏数据、共享对象更新等问题

使用方法：
可以看到定义了两个threadLocalName,threadLocalAge 创建了两个子线程，调用threadLocal的get()和set(),输出的是每个线程里面变量值


public static void main(String[] args) {

    ThreadLocal<String> threadLocalName = new ThreadLocal<>();
    ThreadLocal<Integer> threadLocalAge = new ThreadLocal<>();

    new Thread(()->{
        threadLocalName.set("white");
        threadLocalAge.set(18);
        System.out.println(Thread.currentThread().getName());
        System.out.println(threadLocalName.get());
        System.out.println(threadLocalAge.get());
    },"A").start();

    try {
        TimeUnit.SECONDS.sleep(1);
    }catch (Exception e){

    }

    new Thread(()->{
        threadLocalName.set("black");
        threadLocalAge.set(26);
        System.out.println(Thread.currentThread().getName());
        System.out.println(threadLocalName.get());
        System.out.println(threadLocalAge.get());
    },"B").start();

    try {
        TimeUnit.SECONDS.sleep(1);
    }catch (Exception e){

    }
    System.out.println(Thread.currentThread().getName());
    System.out.println(threadLocalName.get());
    System.out.println(threadLocalAge.get());
}

输出：
A
white
18
B
black
26
main
null
null

四种引用类型

在剖析ThreadLocal源码之前，有必要回顾一下java中的引用类型，threadLocal就用到了弱引用类型：

引用类型	用法	场景以及回收
强引用(Strong Reference)	最常见如:`Object o = new Object();`	只要对象有强引用指向，并且GC Roots可,那么java内存回收时，即使濒临内存耗尽，也不会回收该对象
软引用(Soft Reference)	`SoftReference softReference = new SoftReference<String>(new String("hello world"));`	在即将OOM之前，垃圾回收器会把这些软引用指向的对象加入回收范围，以获得更多的内存空间；如果内存充足，那么垃圾回收的时候也不会回收该引用指向的对象
弱引用(Weak Reference)	`WeakReference weakReference = new WeakReference<String>(new String("hello world"));`	下一次YGC时被回收，由于YGC的不确定性，弱引用何时被回收也具有不确定性
虚引用(Phantom Reference)	必须搭配ReferenceQuene `PhantomReference phantomReference = new PhantomReference<String>(new String("hello world"),new ReferenceQueue<>());`	垃圾回收列入队列进行回收

具体例子

在房产交易中，某个卖家有一套房子，成功出售给某个买家后引用置为null。这里有4个买家使用4种不同的引用关系指向这套房子。买家buyer1是强引用，如果把seller引用赋值给它，则永久有效，系统不会因为为seller=null就触发这套房子的回收，这是房屋交易市场最为常见的交付方式。买家buyer2是软引用，只要不产生OOM，buyer2.get()就可以获取房子对象，就像房子是租来的一样。买家buyer3是弱引用，一旦过户后，seller置为null,buyer3的房子持有时间估计只有几秒钟，卖家只是给买家做了一张假的房产证，买家高兴了几秒钟后，发现房子已经不是自己的了。buyer4是虚引用，定义完成后无法访问到房子对象，卖家只是虚构的房源，是空手套白狼的诈骗术。

原理

既然是一个线程上下文的数据存储结构，那核心方法就是get()和set(),另外还提供remove方法，用于手动回收对象；例如:我们通常用threadLocal来记录请求的会话信息，一个请求进来我们需要记录是哪个uid访问的，可以用set(),线程信息需要uid直接调用get(),如果请求完毕我们进行remove操作。


public class ThreadLocal<T> {
    
    public T get() {}
    
    public void set(T value) {}
    
    public void remove() {}
    
}

set()：如果没有set操作的ThreadLocal,容易引起脏数据问题

public void set(T value) {
    Thread t = Thread.currentThread();
    // 获取当前线程的ThreadLocalMap集合
    // 该map是ThreadLocal的一个静态内部类
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        // 集合为空 将创建一个ThreadLocalMap并将初始值set进去
        createMap(t, value);
}

// 获取当前线程的map集合
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}
// 创建map并将初始值set进去
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

通过ThreadLocal中的set方法，我们发现数据是存在每个线程ThreadLocalMap结构下，那么这个ThreadLocalMap是什么呢？其实ThreadLocalMap是ThreadLocal中一个静态内部类，并且由数组Entry[] table维护某一线程下很多个不同类型的ThreadLocal对象

ThreadLocalMap结构


/**
* 通过查看map的结构 发现map是一个自定义的map 不同于hashMap
* 而且保存数据结构只是一个数组 之所以是数组 是由于一个线程有多种类型ThradLocal
* 数组下标是ThreadLocal对象的hashCode 数组元素是静态内部元素entry
**/
static class ThreadLocalMap {
        
    /**
    * entry是存放数据类 有key和value两个属性
    * key即为ThreadLocal对象本身 并继承弱引用 说明该对象在垃圾回收时会被回收
    * value即为设置进去的值，该对象值是强引用
    **/
    static class Entry extends WeakReference<ThreadLocal<?>> {
        Object value;
        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
    
// 数组初始大小
private static final int INITIAL_CAPACITY = 16;
// 数组
private Entry[] table;

private int size = 0;

private int threshold;

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

private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0);
}

private static int prevIndex(int i, int len) {
    return ((i - 1 >= 0) ? i - 1 : len - 1);
}

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue){};

private ThreadLocalMap(ThreadLocalMap parentMap){};
    
// 获取threadLocal的值
private Entry getEntry(ThreadLocal<?> key){};

// 
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e){};

// 这是设置值的核心方法 
private void set(ThreadLocal<?> key, Object value){

    Entry[] tab = table;
    int len = tab.length;
    // 由ThreadLocal的hashcode计算出数组下标
    int i = key.threadLocalHashCode & (len-1);
    
    //  不断循环该数组下标的元素
    //  因为hash冲突的话 会将该值放进去该值的下一个下标 nestIndex方法起作用
    for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {
        
        ThreadLocal<?> k = e.get();
        // 如果元素刚好是当前操作的ThreadLocal对象 那重新赋值并返回
        if (k == key) {
            e.value = value;
            return;
        }
        // 如果该ThreadLocal对象为空 即有可能被回收
        if (k == null) {
            // 将现在的值重新赋值进去到已有的位置
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    
    // 直接赋值给到数组table
    tab[i] = new Entry(key, value);
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();

}

// 移除元素
private void remove(ThreadLocal<?> key){};

// 将现在的值重新赋值进去到已有的位置
private void replaceStaleEntry(ThreadLocal<?> key, Object value,int staleSlot){
                           int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    int slotToExpunge = staleSlot;
    for (int i = prevIndex(staleSlot, len);(e = tab[i]) != null;i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;

    for (int i = nextIndex(staleSlot, len);(e = tab[i]) != null;i = nextIndex(i, len)) {

        ThreadLocal<?> k = e.get();

        if (k == key) {
            e.value = value;

            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;

            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);

    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
        
}

private int expungeStaleEntry(int staleSlot){};

private boolean cleanSomeSlots(int i, int n){};

private void rehash(){};

private void resize(){};

private void expungeStaleEntries(){};

get()：始终没有get操作的ThreadLocal对象是没有意义的

get方法也是比较简单，如果能找到ThreadLocalMap，那么就从map获取相对应的ThreadLocal的entry即可，如果map为空，则初始化一个新的map,并设置一个null值进去

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        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();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

remove()：如果没有remove操作容易引起内存泄漏

移除的方法比较简单这里忽略解释

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

ThreadLocal副作用

脏数据：如果一个线程使用了ThreadLocal并且不显示地调用remove()清理与线程相关的ThreadLocal信息，那么倘若下一个线程不调用set()设置初始值，就可能get()到重用的线程信息，包括ThreadLocal所关联的线程对象的value值；
内存泄漏：
如果不进行remove()操作，那么Entry中的Value不会被回收，可能会造成内存泄漏

解决方案：必须及时调用remove()方法清理

ThreadLocal原理解析