从源码角度学习ThreadLocal原理

1.ThreadLocal基本介绍

相信使用java语言做开发的同学，肯定多或多或少了解过ThreadLocal，简单来说就是一个“以当前Thread对象作为key的key-value存储结构，能实现多线程的读写安全”。那么他究竟是怎么实现的呢，它的实现源码并不是很长，下面直接从源码上来分析。

先看一个使用ThreadLocal存取数据的例子：

1.1 直接使用无参构造函数创建对象

//使用无参构造函数创建ThreadLocal实例，默认值为null
final ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
            	//给子线程保存局部变量
                threadLocal.set(100);
                System.out.println("线程-" + Thread.currentThread().getId() + ",threadLocal.get() : " + threadLocal.get());
            }
        });
        //给主线程保存局部变量
        threadLocal.set(10);
        thread1.start();
        System.out.println("线程-" + Thread.currentThread().getId() + ",threadLocal.get() : " + threadLocal.get());

执行结果：

线程-1,threadLocal.get() : 10
线程-12,threadLocal.get() : 100

从执行结果中可以看出，两个线程存放变量值虽然都用同一个ThreadLocal变量，但不同线程能获取到正确的变量值的。

1.2 使用带初始值的方式创建对象

ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>(){
    @Override
    protected Integer initialValue() {
        //默认的initialValue返回null,这里直接重写return我们需要的默认值
        return 10;
    }
};
System.out.println("threadLocal存储的默认值：" + threadLocal.get());

执行结果：

threadLocal存储的默认值：10

ThreadLocal的使用可以说是很简单了，下面开始分析，set()、get()方法内部的实现源码。

2.ThreadLocal源码分析

2.1 set()方法：

public void set(T value) {
    Thread t = Thread.currentThread();
    //先获取了当前的线程对象，传给getMap()，获取ThreaLocalMap对象，
    //如果当前线程已经存在ThreadLocalMap对象，则直接存到已有的map中，否则走创建逻辑
    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);
}

• getMap(Thread):

ThreadLocalMap getMap(Thread t) {
	//其实是获取了Thread对象的ThreadLocal.ThreadLocalMap对象
    return t.threadLocals;
}

2.2 get()方法：

先把ThreadLocalMap放一放，再看看get()方法：

    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        //和set()方法方式一样，也是从ThreadLocalMap中获取value
        if (map != null) {
        	//ThreadLocalMap.getEntry()方法，传入的是当前ThreadLocal对象，获取ThreadLocalMap.Entry
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        //如果调用过set()创建过跟Thread对象绑定的ThreadLocalMap对象，
        //则走setInitialValue()方法取默认值
        return setInitialValue();
    }

• 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;
}

2.3 ThreadLocalMap的数据结构

从上面的ThreadLocal的set和get方法可以看出，最后数据都存放到了ThreadLocalMap中。

• 取Value是getEntry(ThreadLocal<?> key)方法，
• 存Value是set(ThreadLocal<?> key, Object value)。

static class ThreadLocalMap {
	//Entry将ThreadLocal对象作为弱引用的key,难道是考虑避免内存泄漏？
	static class Entry extends WeakReference<ThreadLocal<?>> {
   		 Object value;
    	Entry(ThreadLocal<?> k, Object v) {
       		 super(k);
       		 value = v;
   		 }
    }
    //初始容量为16
    private static final int INITIAL_CAPACITY = 16;
    //维护了一个Entry数组，这样就能按这样索引顺序获取value值：ThreadLocal->Entry->Value
    private Entry[] table;
    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    	//每一个ThreadLocalMap对象，都是创建新的Entry数组，就是一个thread对象对应一个
    	//threadlocalmap, 一个threadLocalMap对应一个Entry数组
    	table = new Entry[INITIAL_CAPACITY];
    	//private final int threadLocalHashCode = nextHashCode();
    	//采用hash值取一个尽量不重复的index，比使用循环遍历table数组高效
    	int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    	table[i] = new Entry(firstKey, firstValue);
    	size = 1;
    	setThreshold(INITIAL_CAPACITY);
	}
}

从上面的代码中可以看出ThreadLocalMap的存储结构如下：
下图为不同thread时的存储方式，一个thread对应一个threadLocalMap,也就对应一个Entry数组。

可见，不同的Thread时，用thread对象作为key，将值存档在不同的ThreadLocalMap中。

2.4 ThreadLocalMap.set()

private void set(ThreadLocal<?> key, Object value) {
       Entry[] tab = table;
       int len = tab.length;
       int i = key.threadLocalHashCode & (len-1);
       //这个循环说明，如果当期i位置没有找到，就会逐个的取当前i的下一个位置判断是否已经存在，
       //如果遍历完了table数组还是没有，则直接走循环外的，添加一个新的Entry元素的逻辑
       for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
           ThreadLocal<?> k = e.get();
           //i位置已经存在Entry了，如果key值相等，则替换
           if (k == key) {
              e.value = value;
              return;
           }
           //存在Entry，但是key为null, 
		   if (k == null) {
               replaceStaleEntry(key, value, i);
               return;
           }
       }
       tab[i] = new Entry(key, value);
       int sz = ++size;
       if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
}

• 可以看出该方法中，有判断key为null的情况，其实原因是ThreadLocalMap的key存放的是ThreadLocal的弱引用，如果仅存在ThreadLocalMap中对ThreadLocal对象的弱引用，那么进行GC后，最终这个key会为null，这样一来，就会存在key为null，value不为null的一些键值对。所以replaceStaleEntry就是移除这种元素。

2.5 ThreadLocalMap.getEntry() :

private Entry getEntry(ThreadLocal<?> key) {
		//跟存放时同样的方式获取table的下标
    	int i = key.threadLocalHashCode & (table.length - 1);
    	Entry e = table[i];
    	if (e != null && e.get() == key)
        	return e;
    	else
    		//内部会清理掉对应value避免内存泄漏
        	return getEntryAfterMiss(key, i, e);
   }
   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)
        	//发现key为null,说明对应的threadLocal对象已经被回收，需要清理掉对应value避免内存泄漏
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

    如果简单的理解，其实ThreadLocalMap就是一个由数组实现的hash表，在获取Entry时能够通过先计算出hash值，然后直接通过table[hash]的方式获取value。

3.ThreadLocalMap存储的问题分析

3.1 同一个对象存放多个不同类型对象

怎么存储多个不用类型，比如我想在同一个Thread里存放10个不同类型的对象，那代码就会如下：

ThreadLocal<Integer> integerThreadLocal = new ThreadLocal<>();
threadLocal.set(10);
//存放double类型变量
ThreadLocal<Double> doubleThreadLocal = new ThreadLocal<>();
doubleThreadLocal.set(88.000);
//存放float类型变量
ThreadLocal<Double> FloatThreadLocal = new ThreadLocal<>();
doubleThreadLocal.set(88.000);

    这种情况下，因为是同一个thread实例，所以ThreadLocalMap也会是同一个对象，也就是共用一个Entry数组，只是ThreadLocal对象不同，也就是ThreadLocalMap的key不同，所以会存放到table数组的不同位置。
同一个对象存放多个不同类型对象时结构如下：

    这种情况下，对应关系就会如上所示，一个thread实例，一个threadLocalMap对象，然后根据不同的threadLocal对象，计算出不同的hash值，得出的数组下标不同，就会存放到同一个table数组的不同位置。当然这种情况也可直接将不同的类型对象组合为一个类就可以了。

3.2 内存泄漏问题

    如前面2.4所说，在ThreadLocalMap中，作为key的ThreadLocal对象，是用弱引用的方式引用的，但是真正存放的value仍然是强引用，所以在ThreadLocalMap中会有对当key为null时，清理key为null的Entry元素。但是这些清理操作，都是需要触发set(),getEntry()的调用才会被执行，这样一来，如果key已经为null了，但是又没有在进行set()/get()存取操作，那么还是会存在value的内存泄漏问题，所以在使用ThreadLocal完毕后，最好使用remove(）方法，清理掉对应ThreadLocalMap对象。