一篇文章让你彻底搞懂ThreadLocal（深度剖析）

---

前言

学会并理解ThreadLocal还是很有必要的，不论是工作中使用，还是看源码时，如spring事务的部分实现、ReentrantReadWriteLock读写锁源码都会用到这个线程本地变量！

---

一、ThreadLocal介绍

ThreadLocal是jdk包提供的，他提供了线程本地变量，如你创建了一个ThreadLocal变量，那么访问这个变量的每个线程，都会有自己的本地副本。当多线程操作这个变量时，实际操作的是自己的本地内存的变量，从而避免了线程安全问题，因为对其他线程都是不可见的。
但是设计初衷是为了保证多线程之间数据的隔离性。

---

使用案例

先来个简单的案例入门，方便后续深入了解

public class ThreadLocalTest {

    static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    private static void pri(String str){
        System.out.println("pri----------------------"+str+":"+threadLocal.get());
//        threadLocal.remove();
    }

    public static void main(String[] args) {
        Thread one = new Thread(()->{
            threadLocal.set("线程1 local");
            pri("线程1");
            System.out.println("线程1 remove after："+threadLocal.get());
        });

        Thread two = new Thread(()->{
            threadLocal.set("线程2 local");
            pri("线程2");
            System.out.println("线程2 remove after："+threadLocal.get());
        });
        one.start();
        two.start();
    }
}

打印结果：

pri----------------------线程2:线程2 local
线程2 remove after：线程2 local
pri----------------------线程1:线程1 local
线程1 remove after：线程1 local

通过打印结果可以看到，在pri（）方法里，不同的线程输出了各自的存储变量。

---

上面有一行这个代码被注释了，现在放开注释执行。

// threadLocal.remove();

执行结果：

pri----------------------线程2:线程2 local
pri----------------------线程1:线程1 local
线程2 remove after：null
线程1 remove after：null

今天看到执行remove方法之前，他是一直存在的。

---

二、ThreadLocal实现原理

先看一下ThreadLocal相关类的类图结构

Thread类本身就具有2个变量，threadLocals和inheritableThreadLocal他们都是TheadLocalMap类型

TheadLocalMap可以理解为一个定制化的HashMap

ThreadLocal本身他是一个工具类。
他通过set方法把本地变量放进当前线程的threadLocals里并存起来。
调用get方法再从当前线程的threadLocals里取出来使用。
线程如果一直不终止并且也没有执行remove方法的情况下，那这个本地变量会一直存放在threadLocals里。

---

2.1、set方法-源码分析

public void set(T value) {
		// 1、获取当前线程实例
        Thread t = Thread.currentThread();
        // 2、获取当前线程的本地副本变量
        ThreadLocalMap map = getMap(t);
        if (map != null)
        	// 3、hashMap里插入value
            map.set(this, value);
        else
        	// 4、第一次调用就创建当前线程对应的HashMap并插入value
            createMap(t, value);
    }

代码1、没啥好说的，直接获取当前线程实例

代码2、把线程实例作为参数，调用getMap方法

ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

可以看到这里实际上就是获取了线程实例的变量threadLocals。

代码3、如果不是空，就插入value

代码4、进到这里肯定是第一次调用，就创建当前线程的HashMap，并初始化

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

---

2.2、get方法-源码分析

public T get() {
		
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        // 1、如果不为null,则返回对应的值
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        // 2、如果threadLocals为空，则初始化当前线程的threadLocals变量
        return setInitialValue();
    }

代码1、如果不为空，直接获取对应的值，否则执行代码2、进行初始化。
setInitialValue代码如下：

private T setInitialValue() {
		// 1、初始化为null
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        // 2、不为空就插入值
        if (map != null)
            map.set(this, value);
        else
        	// 3、为空则初始化，value设置null
            createMap(t, value);
        return value;
    }
protected T initialValue() {
        return null;
    }

threadLocals不为空，本地变量就设置为null,否则就创建当前线程的threadLocals。

---

2.3、remove方法-源码分析

// 移除此线程局部变量的当前线程值
public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }
private void remove(ThreadLocal<?> key) {
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                if (e.get() == key) {
                    e.clear();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }

线程本地变量不为null,就移除。
remove底层实现就是循环遍历数组，然后clear掉。

2.4、

---

三、ThreadLocalMap源码分析

ThreadLocalMap底层结构：
可以看到就是一个简单的k/v的Entry数组。

3.1、核心属性

这里需要注意，Entry继承了WeakReference(弱引用)

static class ThreadLocalMap {

        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; // Default to 0
}

3.2、 构造方法

初始化，就创建数组，长度默认为16.哈希取模就是存储的位置。元素个数为1

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
			// 创建初始化数组，数组长度16
            table = new Entry[INITIAL_CAPACITY];
            // hash取模，得到存放在数组哪个位置
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            // 插入元素
            table[i] = new Entry(firstKey, firstValue);
            // 数组元素设置1
            size = 1;
            // 设置阈值默认为0
            setThreshold(INITIAL_CAPACITY);
        }

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

3.3、set方法-核心方法

都知道hashmap是数组+链表，Hash冲突当前位置上就会变成一个链表，可是现在这个结构，他是数组，那他是如何解决Hash冲突的呢？
带着这个目的去看下面的源码：

private void set(ThreadLocal<?> key, Object value) {

        	// 1、获取当前数组实例
            Entry[] tab = table;
            // 2、当前数组长度
            int len = tab.length;
            // 3、key的hash取模，获取插入位置
            int i = key.threadLocalHashCode & (len-1);
			// 4、找到插入的位置，如果当前位置上不为null,说明发生了hash冲突。
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                 // 5、获取当前插入位置的元素key
                ThreadLocal<?> k = e.get();
				// 6、判断当前位置上的key和插入的key是否相等，相等则覆盖value,然后结束set方法
                if (k == key) {
                    e.value = value;
                    return;
                }
				// 7、如果当前位置的key为null,则初始化一个entry放在要插入的位置上
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

这里需要关注2个地方
代码6、如果当前位置key和准备插入的key相等，value就直接覆盖。
代码7、如果当前位置为null,就在当前位置上 初始化entry。
如果key既不相等也不为null,说明发生了hash冲突，则调用nextIndex方法，源码如下：
插入的位置+1,如果小于数组长度就插入在当前位置的后一格位置（如果一直冲突就一直遍历后一格），
否则插入在数组【0】上。

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

set操作如图：

---

3.4、getEntry方法

private Entry getEntry(ThreadLocal<?> key) {
			// 1、hash取模获取到key的位置
            int i = key.threadLocalHashCode & (table.length - 1);
            // 2、拿到元素
            Entry e = table[i];
            // 3、不为null 并且是当前线程，直接返回元素
            if (e != null && e.get() == key)
                return e;
            else
            	// 4、hash冲突的处理，往当前位置后的遍历去找
                return getEntryAfterMiss(key, i, e);
        }

获取当前key的元素时，如果当前位置为空、或者不等于当前key，则执行getEntryAfterMiss方法，源码如下：

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;
			// 核心重点的地方
            while (e != null) {
                ThreadLocal<?> k = e.get();
                // 相等就返回
                if (k == key)
                    return e;
                    // 为空说明是脏数据，就删除，调整数组位置
                if (k == null)
                    expungeStaleEntry(i);
                else
                	// 以上都不满足，则继续去下一个位置上寻找
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }

get和set元素的时候逻辑相同，都是按取模的位置上找，找不到就往靠后的位置上找，
不同的是get这里key等于null的时候会执行expungeStaleEntry方法，主要是删除脏数据，以及数组位置前移。

---

四、ThreadLocal存在的问题-可能造成内存泄漏

4.1、先说一下什么是弱引用

只具有弱引用的对象拥有更短暂的生命周期，在垃圾回收器线程扫描它所管辖的内存区域的过程中，
一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。
不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。

static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

threadlocal保存的时候会把自己作为key,正常情况下key和value是被外界强引用，但是这里他继承了WeakReference（弱引用）；
这就会出现一个问题，在他没有被外界强引用的时候，如果发生了GC回收到他了，他的key就被回收了，但是他的value还在，这个线程一直在运作，导致value一直无法被回收，最终造成内存泄漏。

---

4.2、怎么解决弱引用？

在代码的最后使用remove就好了，我们只要记得在使用的最后用remove把值清空就好了。

---

4.3、为什么ThreadLocalMap的key要设计成弱引用？

如果不设计成弱引用，就可能和value一样造成内存泄漏。

---

总结

每个线程内部都有一个threadlocals的成员变量，该变量结构为HashMap，key为线程实例，value为set的值；
线程没消亡，或者没remove则当前线程的本地变量会一直存在，直至消亡或者remove掉。
因此开发使用ThreadLocal时，务必在结尾处添加remove方法，防止内存泄漏。