大家或多或少听说过ThreadLocal这个词,我们创建的对象默认是所有线程可以访问的,多线程并发修改对象时就会可能出现数据不一致的问题,使用ThreadLocal创建的对象只能被当前线程访问，每个线程保存一个对象的副本,在多线程操作时是线程安全的。

ThreadLocal用法简介

比如有这样一个类:

public class Counter{
	private int count;
 	public Counter(int cnt) {
            this.count = cnt;
    }
	//省略setter()和getter()方法
}

我们希望多线程访问Counter对象时，各个线程各自保留一份count计数,那可以这么写:

ThreadLocal<Counter> threadLocal = new ThreadLocal<>();
threadLocal.set(new Counter(0));
Counter counter = threadLocal.get();

如果你不想每次调用的时候都去初始化,那可以重写ThreadLocal的initValue()方法给ThreadLocal设置一个对象的初始值,如下所示:

ThreadLocal<Counter> threadLocal = new ThreadLocal<Counter>() {
    @Override
    protected Counter initialValue() {
        return new Counter(0);
    }
};

这样每次调用threadLocal.get()的时候，会去判断当前线程是否存在Counter对象,如果不存在则调用initValue()方法初始化。

ThreadLocal实现原理

我们先来看一下ThreadLocal的get()方法，如下所示:

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();
}

调用get()方法时先获取到当前线程,然后通过线程获取每个线程绑定的ThreadLocalMap对象,map中的key就是ThreadLocal对象,Value就是实际我们要访问的对象，上面的例子中是Counter对象,如果Entry为空,那就调用setInitialValue()方法设置初始值。

ThreadLocalMap实现原理

从前面可以看出每个线程内部有个ThreadLocalMap,从java.lang.Thread类的源码也可以看到Thread类有个ThreadLocal.ThreadLocalMap threadLocals属性,接下来我们来分析下它的实现原理:
ThreadLocalMap和WeakHashMap实现有点类似，也是利用了WeakReference来和GC建立关联,因为ThreadLocal对象被线程对象引用，如果一个线程的生命周期比较长,那可能会出现内存泄露的问题，ThreadLocalMap借助弱引用巧妙的解决了这个问题，源码如下所示:

static class ThreadLocalMap {
    static class Entry extends WeakReference<ThreadLocal<?>> {
        /** The value associated with this ThreadLocal. */
        Object value;
		//这里的Entry并不是一个链表,如果出现hash碰撞,会放到数组的下一个位置
        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
}

从源码可以看到ThreadLocalMap的Entry继承自WeakReference,Entry中的key是一个弱引用，也就是说线程类持有了ThreadLocal对象的一个弱引用,当ThreadLocal对象没有其他强引用关联时,在GC时会把ThreadLocal对象回收掉，但是这里仅仅回收ThreadLocal对象,Entry对象和Value并没有回收,ThreadLocalMap里就可能存在很多Key为null的Entry,所以需要在调用map.getEntry()时对key为null的对象进行处理,源码如下:

private Entry getEntry(ThreadLocal<?> key) {
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    if (e != null && e.get() == key)
        return e;
    else
		//当前位置没有找到,可能Hash碰撞了
        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)
			//检测到有个ThreadLocal对象被回收了,这个时候去清理后面所有Key为null的Entry
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

从源码中可以看到ThreadLocalMap清理掉key为Null的Entry的时机是根据ThreadLocal对象的hashCode去获取entry时发生了hash碰撞,并且下一个entry的key为null时才去清理,因为ThreadLocalMap的Entry和普通Map的不太一样，一般的Map是一个链表数组，而它的数组每个元素就是一个Entry，如果出现Hash碰撞了就放到数组的下一个位置,因此如果get的时候发现没有碰撞可以认为当前Map中的元素还不多，一旦检测到碰撞了并且下一个entry的key被回收了,就调用expungeStaleEntry（）来释放ThreadLocal为null的那些entry,避免了内存泄露。

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) {
			//清理key为null的entry
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            int h = k.threadLocalHashCode & (len - 1);
			//hashCode发生了变化,重新放置entry
            if (h != i) {
                tab[i] = null;
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}

总结

ThreadLocal可以保证每个线程拥有一个变量的副本，实现了线程隔离,主要利用了每个Thread有个ThreadLocalMap,ThreadLocalMap保存了该线程拥有的所有ThreadLocal对象，并利用弱引用机制避免了Map无线增大导致内存泄露的问题。