ThreadLocal源码分析

根据ThreadLocal的定义，很容易想到的实现方法是在ThreadLocal内部定义一个Map，Key保存线程，Value保存值。

但是JDK并不是这样完成的，反而是在每个Thread中保存了ThreadLocalMap的引用，而一个ThreadLocalMap中保存着一组Entry实例，Entry实例内部即是一个ThreadLocal和他所存储的Value值。

static class ThreadLocalMap {
        private Entry[] table;

        private int size = 0;

        private int threshold;
        
        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }
        
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

初始化的方法和HashMap有异曲同工之妙，具体的方法操作我们通过一般使用ThreadLocal的方法来看一看。

 

首先我们一般会重写一个initValue()

protected T initialValue() {
        return null;
    }

不出意料方法体内为空，而JDK注释里指出

This method will be invoked the first
time a thread accesses the variable with the {@link #get}
method, unless the thread previously invoked the {@link #set}
method, in which case the {@code initialValue} method will not
be invoked for the thread

意思是这个方法只会在某个线程第一次通过get方法访问变量时调用。除非先行调用了set，此时这个方法不会被调用。

那我们接下来看看set方法和get方法

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);//从当前线程中获得ThreadLocalMap
        if (map != null)//map不为空时直接设值
            map.set(this, value);
        else//为空时，初始化创建一个map（懒加载）
            createMap(t, value);
    }

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

private void set(ThreadLocal<?> key, Object value) {
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);//根据hashcode获得在数组的索引

            //遍历桶（开发地址法）
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                 //获取ThreadLocal
                ThreadLocal<?> k = e.get();

                //是所需要的Key，设值返回
                if (k == key) {
                    e.value = value;
                    return;
                }

                //过期（被回收），替代过期值返回
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            //获得索引值开始第一个非null的i，新建Entry存入
            tab[i] = new Entry(key, value);
            //如果超过threshold扩容（参照HashMap）
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

 

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);//从当前线程中获得ThreadLocalMap
        if (map != null) {//map不为空时
            ThreadLocalMap.Entry e = map.getEntry(this);//从Map中根据Key（ThreadLocal）找到对应的Entry
            if (e != null) {//找到（Entry不为空）
                @SuppressWarnings("unchecked")
                T result = (T)e.value;//值就是Value
                return result;//返回
            }
        }
        return setInitialValue();//map为空 或者 map不为空但没有当前ThreadLocal所存的值（可能存在其他ThreadLocal）
    //设置当前ThreadLocal的初始值
    }

private Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];//根据hashcode获得在数组的索引
            if (e != null && e.get() == key)//找到（Entry不为空），直接返回
                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];
            }
            //遍历到第一个为null的都没找到，即桶内没有该元素，返回null
            return null;
        }

 

我们可以在以上方法中看到，当访问ThreadLocalMap中的Key（ThreadLocal）为空的时候，

getEntry会调用expungeStaleEntry(int staleSlot)，set会调用replaceStaleEntry(ThreadLocal<?> key, Object value,int staleSlot)，

这两个方法都是清理空Key（null）的value值的。

是因为ThreadLocal本身存值是存放在Entry中的，当ThreadLocal被程序员主动释放（null）的时候，ThreadLocal在Map中的软引用也立刻被释放，

但是其对应的Value在Map中仍被引用，无法被释放。

而因为是用的开放地址法处理哈希冲突，删除对应值的时候需要重新计算后续元素的哈希值，并也会发现其他没被清理的值。

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

            // 清除指明的点的value
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;

            // 重新计算哈希
            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为空而entry不为空，需要清除
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {//key不为空，重新计算哈希值
                    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;
        }