ThreadLocal是什么，底层原理

ThreadLocal是什么，底层原理

1. ThreadLocal是什么？

从名字我们就可以看到ThreadLocal 叫做本地线程变量，意思是说，ThreadLocal 中填充的的是当前线程的变量，该变量对其他线程而言是封闭且隔离的，ThreadLocal 为变量在每个线程中创建了一个副本，这样每个线程都可以访问自己内部的副本变量。

从字面意思很容易理解，但是实际角度就没那么容易了，作为一个面试常问的点，使用场景也是很丰富。

• 1、在进行对象跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束。
• 2、线程间数据隔离
• 3、进行事务操作，用于存储线程事务信息。
• 4、数据库连接，Session会话管理。

现在相信你已经对ThreadLocal有一个大致的认识了，下面我们看看如何用？

public class ThreadMain {

    public static void main(String[] args) {
        ThreadLocal<String> t = new ThreadLocal<>();
        //当作是一个类似集合容器的对象来使用
        //set get remove
        t.set("xqc");
        //t.set("xxx");
        String result = t.get();
        System.out.println(result);
        //1.集合
        // list-set add(v)
        // map      put(k,v)
        
        //2.解决线程安全问题
        // synchronized
    }
}

2.ThreadLocal源码分析

1.set方法

源代码如下

/**
 * Sets the current thread's copy of this thread-local variable
 * to the specified value.  Most subclasses will have no need to
 * override this method, relying solely on the {@link #initialValue}
 * method to set the values of thread-locals.
 *
 * @param value the value to be stored in the current thread's copy of
 *        this thread-local.
 */
public void set(T value) {
    Thread t = Thread.currentThread(); //获取当前线程对象
    ThreadLocalMap map = getMap(t); //获取当前线程独有的获取线程中变量 ThreadLocal.ThreadLocalMap，通过秘钥自身来获取
    if (map != null)   //如果获取到的ThreadLocalMap不为空，则直接存进
        map.set(this, value);
    else //如果为空，初始化该线程对象的map变量，其中key为当前的threadlocal变量
        createMap(t, value);
}

getMap源码

 /**
     * Get the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param  t the current thread
     * @return the map
     */
    ThreadLocalMap getMap(Thread t) {
       
        return t.threadLocals; //threadLocals为当前线程对象的一个属性，类型是  																			ThreadLocal.ThreadLocalMap
    }

可以看出ThreadLocalMap对象是被Thread类持有的

createMap源码

/**
     * Create the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     */
//该方法在获取到的ThreadLocalMap为空情况下调用
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);//初始化一个ThreadLocalMap对象,this为ThreadLoad对象
    }

接下来研究ThreadLocalMap()

/**
 * Construct a new map initially containing (firstKey, firstValue).
 * ThreadLocalMaps are constructed lazily, so we only create
 * one when we have at least one entry to put in it.
 */
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    table = new Entry[INITIAL_CAPACITY]; //默认值为16
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); //hash计算存储下标
    table[i] = new Entry(firstKey, firstValue); //创建Entry对象存储K,V，然后存放进table[]
  
    size = 1;
    setThreshold(INITIAL_CAPACITY);
}

Entry对象

/**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

汇总下，ThreadLocalMap 为 ThreadLocal 的一个静态内部类，里面定义了Entry 来保存数据。而且是继承的弱引用。在Entry内部使用ThreadLocal作为key，使用我们设置的value作为value。

其Entry使用的是K-V方式来组织数据，Entry中key是ThreadLocal对象，且是一个弱引用（弱引用，生命周期只能存活到下次GC前）。

对于每个线程内部有个ThreadLocal.ThreadLocalMap 变量，存取值的时候，也是从这个容器中来获取。

2.get方法

/**
 * Returns the value in the current thread's copy of this
 * thread-local variable.  If the variable has no value for the
 * current thread, it is first initialized to the value returned
 * by an invocation of the {@link #initialValue} method.
 *
 * @return the current thread's value of this thread-local
 */
public T get() {
    Thread t = Thread.currentThread(); //获取当前线程对象
    ThreadLocalMap map = getMap(t); //获取当前线程独有的Map对象，线程中变量 ThreadLocal为秘钥
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);//通过this（ThreadLocal）获取对应线程的Map
        if (e != null) {//不为空则取出其value
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

通过上面的分析，相信你对该方法已经有所理解了，首先获取当前线程，然后通过key threadlocal 获取 设置的value 。

弱引用引发的问题

看看官话，为什么要用弱引用。

To help deal with very large and long-lived usages, the hash table entries use WeakReferences for keys.
为了处理非常大和生命周期非常长的线程，哈希表使用弱引用作为 key。

• 生命周期长：暂时可以想到线程池中的线程

ThreadLocal在没有外部对象强引用时如Thread，发生GC时弱引用Key会被回收，而Value是强引用不会回收，如果创建ThreadLocal的线程一直持续运行如线程池中的线程，那么这个Entry对象中的value就有可能一直得不到回收，发生内存泄露。

• key 如果使用强引用：引用的ThreadLocal的对象被回收了，但是ThreadLocalMap还持有ThreadLocal的强引用，如果没有手动删除，ThreadLocal不会被回收，导致Entry内存泄漏。
• key 使用弱引用：引用的ThreadLocal的对象被回收了，由于ThreadLocalMap持有ThreadLocal的弱引用，即使没有手动删除，ThreadLocal也会被回收。value在下一次ThreadLocalMap调用set,get，remove的时候会被清除。

Java8中已经做了一些优化如，在ThreadLocal的get()、set()、remove()方法调用的时候会清除掉线程ThreadLocalMap中所有Entry中Key为null的Value，并将整个Entry设置为null，利于下次内存回收。

内存结构：

实线箭头表示强引用，虚线箭头表示弱引用

Java8中for循环遍历整个Entry数组，遇到key=null的就会替换从而避免内存泄露的问题。

private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

            // expunge entry at staleSlot
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;

            // Rehash until we encounter null
            Entry e;
            int i;
            for (i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                    if (h != i) {
                        tab[i] = null;
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

通常ThreadLocalMap的生命周期跟Thread（注意线程池中的Thread）一样长，如果没有手动删除对应key（线程使用结束归还给线程池了，其中的KV不再被使用但又不会GC回收，可认为是内存泄漏），一定会导致内存泄漏，但是使用弱引用可以多一层保障：弱引用ThreadLocal会被GC回收，不会内存泄漏，对应的value在下一次ThreadLocalMap调用set,get,remove的时候会被清除，Java8已经做了上面的代码优化。

有些文章认为是弱引用导致了内存泄漏，其实是不对的。假设把弱引用变成强引用，这样无用的对象key和value都不为null，反而不利于GC，只能通过remove()方法手动清理，或者等待线程结束生命周期。也就是说ThreadLocalMap的生命周期由持有它的线程来决定，线程如果不进入terminated状态，ThreadLocalMap就不会被GC回收，这才是ThreadLocal内存泄露的原因。

总结

• 每个ThreadLocal只能保存一个变量副本，如果想要一个线程能够保存多个副本以上，就需要创建多个ThreadLocal。
• ThreadLocal内部的ThreadLocalMap键为弱引用，会有内存泄漏的风险。
• 每次使用完ThreadLocal，都调用它的remove()方法，清除数据。