ThreadLocal源码解析

1.成员变量：

threadLocalHashCode

private final int threadLocalHashCode = nextHashCode();

 private static AtomicInteger nextHashCode =
    new AtomicInteger();

private static final int HASH_INCREMENT = 0x61c88647;

private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

这是一个自定义哈希代码（仅在ThreadLocalMaps中有用)，类比HashMap中使用Object.hashCode()生成hash码，在ThreadLocal中只是自己生成。它可以消除常见情况下的冲突，其中连续构造的ThreadLocals被相同的线程使用，同时在一些不常见的情况下能够保持threadlocal良好行为。

---

2.内部类

ThreadLocalMap
ThreadLocalMap可以看做是hashMap（但是其和HashMap并没有任何的关系，只是其内部实现和HashMap类似，使用了哈希表的方法）仅用于维护当前线程的本地变量值。仅ThreadLocal类对其有操作权限（静态，私有）同时这个类也是Thread类的私有属性。为避免占用空间较大或生命周期较长的数据常驻于内存引发一系列问题，Map中的entry使用了弱引用WeakReferences。当空间不足时，会清理未被引用的entry。

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

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

这个类是ThreadLocalMap中的内部类，继承了WeakReference使其成为了一个弱引用类型的类， 请注意，null键（即entry.get（）== null）表示该键不再被引用，因此该条目可以从表中删除。
该方法是父类Reference中的方法

public T get() {
    return this.referent;
}

SuppliedThreadLocal extends ThreadLocal

static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {

    private final Supplier<? extends T> supplier;

    SuppliedThreadLocal(Supplier<? extends T> supplier) {
        this.supplier = Objects.requireNonNull(supplier);
    }

    @Override
    protected T initialValue() {
        return supplier.get();
    }
}

JDK8新增的内部类，扩展了ThreadLocal的初始化值的方法，允许使用JDK8新增的Lambda表达式赋值

3.主要方法

get()

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

得到当前线程中的ThreadLocalMap变量（前面提到过每个Thread中都有一个ThreadMap成员变量）然后将当前这个ThreadLocal对象传入，包装成Entry 存入map中。

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

得到线程的ThreadMap对象，然后通过getEntry(this)得到节点（本地变量也就存放在节点中）

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

当get()操作没有查询到当前ThreadLocal对象作为key的值时 不返回null 而是返回了 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;
}

实则就是如果map中没有这个key 则加入这个ThreadLocal(作为key) 值为null 并返回。说以我们在使用ThreadLocal是如果我们在没有set()操作前进行了get()那么得到的值是null

remove()

public void remove() {
     ThreadLocalMap m = getMap(Thread.currentThread());
     if (m != null)
         m.remove(this);
 }

TreadLocalMap中的remove实现：

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

clear()方法是调用了父类Reference中的方法：

public void clear() {
    this.referent = null;
}

referent为Reference的成员变量值为null了之后会被GC进行处理

withInitial()

public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
    return new SuppliedThreadLocal<>(supplier);
}

withInitial()用于支持Lambda表达式赋值

总结：每个Thread中都有一个存储ThreadLocal及其值得Map 所有的线程对ThreadLocal的操作都是对自己Map中的ThreadLocal进行操作，从而实现了变量在线程之间的隔离性。