ThreadLocal学习笔记

ThreadLocal的作用主要是做数据隔离，填充的数据只属于当前线程，变量的数据对别的线程而言是相对隔离的，在多线程环境下，防止自己的变量被其它线程篡改。
线程进来之后初始化一个泛型的ThreadLocal对象，之后这个线程只要在remove之前去get，都能拿到之前set的值，能做到线程间数据隔离的，所以别的线程使用get（）方法是没办法拿到其他线程的值的。

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

这个方法会先获取当前线程,因此不会取到其他线程所用户的变量值,这里我们关注一下getMap方法;

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

这个方法返回Thread的threadLocals属性,threadLocals的类型是ThreadLocal.ThreadLocalMap,正如他的名字,他和map的设计是类似的.
不过ThreadLocalMap的底层数据结构是数组,并不像hashmap是数组链表红黑树的设计,所以在向map中add的时候的操作是和hashmap很不一样的;
当遇到hash冲突时,ThreadLocalMap会先判断当前数组计算出的位置是否有数据,如果已经存在数据则说明发生hash冲突,则继续遍历该数组找到下一个为空的位置将需要add的变量放置进去;

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

            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);
            // 找到从计算出的i位置开始的第一个为null的位置
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                if (k == key) {
                    e.value = value;
                    return;
                }

                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
            // 插入数据
            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

同理,get的时候也是先hash运算计算出i值,再从数组中判断该位置key == 传入的threadlocal,如果true,则返回value, 如果false则接着遍历链表找到key == 传入的threadlocal为止.

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
                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)
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }

ThreadLocal存在的问题: 可能发生内存泄漏;
我们观察Entry类:

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

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

发现Entry类被设计为extends WeakReference,也就是弱引用,这样会导致一种情况,当threadlocal没有强引用时,发生gc会将entry的key(即threadlocal对象)回收,如果持有该threadlocal的线程一直运行,那么value因为是强引用,这就导致key被回收,而value无法被回收的情况.
解决方法:
在使用threadlocal后,记得使用remove方法就可以了.

ThreadLocal<String> localName = new ThreadLocal();
try {
    localName.set("张三");
    ……
} finally {
    localName.remove();
}