ThreadLocal原理及内存泄漏

背景

同一个变量，如果多线程访问，那么就会出现线程安全问题，为了线程安全，就需要使用锁（lock、sync）来保证线程安全，那么效率就会降低
某些变量，需要在函数调用中传递，编码复杂
基于上面两种情况，可以考虑使用ThreadLocal来保存这部分变量。使变量易于管理，编码优美。

使用方式

@RestController
@RequestMapping("/autoconfig")
public class TestAutoConfigController {

    private static ThreadLocal<String> LOCAL = new ThreadLocal<>();

    @GetMapping("/test")
    public Object get() {
        System.out.println(LOCAL.get());
        LOCAL.set("test");
        return "11";
    }
}

源码解析

public class ThreadLocal<T> {
    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();
    }

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            map.set(this, value);
        } else {
            createMap(t, value);
        }
    }

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

	// 从这里看到，map是和Thread里面的一个属性
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

	// 保存数据
    static class ThreadLocalMap {

        static class Entry extends WeakReference<ThreadLocal<?>> {
            Object value;
            Entry(ThreadLocal<?> k, Object v) {
            	// 调用父类weakreference
                super(k);
                value = v;
            }
        }
        
        private Entry[] table;
	}
}

public class WeakReference<T> extends Reference<T> {
	    public WeakReference(T referent) {
        super(referent);
    }
}

public class Thread implements Runnable {
	ThreadLocal.ThreadLocalMap threadLocals = null;
}

get

内存泄漏

首先要明确一个引用链，Thread -> ThreadLocalMap -> Entry[] -> Entry，当使用到ThreadLocal时，首先会在ThreadLocalMap的Entry[]中，创建一个Entry。entry对象内部有两个属性，key、value。key是通过ThreadLocal建立的弱引用，value是存储的数据。
当ThreadLocal对象只有这一个弱引用是，遇到GC时，就会被回收调。此时entry对象的key属性就变成了null。而当map里面的任意一个ThreadLocal执行get、set、remove方法时，都会清楚Entry[]中entry对象key=null的entry。这一套组合拳下来，大大的降低了内存泄漏的概率。
那么，内存泄漏是如何产生的呢？
即使是回收了ThreadLocal对象，entry的key也变成null了，但是线程中没有对ThreadLocalMap进行任何的get、set、remove操作了，这就导致了Map中的value一直没有被回收。如果线程一直常驻，那么就会出现内存泄漏。

1.8的优化

1.8版本前后，也是有一定的差别。
1.8之前，每个ThreadLocal都会创建一个ThreadLocalMap，其中，线程作为key，保存的数据作为value。直接保存在ThreadLocalMap中。这样key的数量与线程数直接相关，就可能会造成哈希冲突。
1.8及之后， 每个ThreadLocal，对于每个线程来说，都会创建一个ThreadLocalMap，其中，ThreadLocal为key，保存的数据为value。

这么做的好处？

1、这样ThreadLocal的数量其实远远小于线程数量，有效减少了哈希冲突。
2、每个线程创建的map能够跟随线程的销毁而回收。但是不能解决内存泄漏问题，ThreadLocal使用完成后，必须调用remove()方法。

为什么建议使用static修饰ThreadLocal？

本身和ThreadLocalMap中相关的就是ThreadLocal，作为一个key，本身并没有存储功能，而线程间的ThreadLocalMap又都是隔离的，所以用static修饰ThreadLocal完全没有问题。