java并发（3）ThreadLocal的使用及实现原理(实现原理)

T

get()

protected T

initialValue()

void

remove()

void

set(T value)

static <S> ThreadLocal<S>

withInitial(Supplier<?
extends S> supplier)

protected T initialValue() {
return null;
}

public void set(T value) {
Thread t = Thread.currentThread();//获得当前变量线程t
ThreadLocalMap map = getMap(t); //获得当前线程的ThreadLocalMap
if (map != null)
map.set(this, value);  //将this作为键，在get的时候同一个ThreadLocal通过get(this)的方式就能直接取到值
else
createMap(t, value); //如果当前线程没有ThreadLocalMap，则新建一个
}

ThreadLocalMap getMap(Thread t) {
return t.threadLocals; //直接返回当前线程的threadLocals，之前提到过Thread类中有一个threadLocals变量，该变量正是ThreadLocalMap类型的
}

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

/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;

static class ThreadLocalMap {

/**
* The entries in this hash map extend WeakReference, using
* its main ref field as the key (which is always a
* ThreadLocal object).  Note that null keys (i.e. entry.get()
* == null) mean that the key is no longer referenced, so the
* entry can be expunged from table.  Such entries are referred to
* as "stale entries" in the code that follows.
*/
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;

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

...

/**
* The initial capacity -- MUST be a power of two.
*/
private static final int INITIAL_CAPACITY = 16; //容量初始值

/**
* The table, resized as necessary.
* table.length MUST always be a power of two.
*/
private Entry[] table; //哈希表

/**
* The number of entries in the table.
*/
private int size = 0; //当前哈希表中实体个数

/**
* The next size value at which to resize.
*/
private int threshold; // Default to 0  加载因子

/**
* Set the resize threshold to maintain at worst a 2/3 load factor.
*/
private void setThreshold(int len) {
threshold = len * 2 / 3;
}

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); //通过key的HashCode算出Entry对象应该在table中的坐标

for (Entry e = tab[i];
e != null; //如果计算出的坐标处已经存在
e = tab[i = nextIndex(i, len)]) { //找该坐标的下一个位置，直到找到一个空位
ThreadLocal<?> k = e.get();  //取得计算出的坐标的Entry对象

if (k == key) {  //如果该坐标中的Entry的key和要插入的值得key相同，说明只用将之前key对应的值修改成要插入的值就可以返回了
e.value = value;
return;
}

if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}

tab[i] = new Entry(key, value); //如果计算出的坐标处是空位，则插入一个新的Entry对象，然后将对象个数size++
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}

public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this); //set的时候后将自身作为键，get的时候使用this就可以取得值，敢于该方法，在下面介绍
if (e != null) { //如果取得的Entry不为空，就将Entry的value返回。
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue(); // 如果当前线程还没有持有ThreadLocalMap实例或者在当前线程的ThreadLocalMap中没有取得Entry实例，就调用初始化方法。
}

private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1); //将key的hashCode和table的长度进行与运算计算出该key对应的Entry对应在hash表table中的坐标i
Entry e = table[i]; //取出Entry
if (e != null && e.get() == key) // 如果取出的Entry不为空并且key = Entry中的key，将该Entry返回
return e;
else  // 否则调用getEntryAfterMiss方法
return getEntryAfterMiss(key, i, e);
}

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) { //参数key传入的当前ThreadLocal对象
Entry[] tab = table;
int len = tab.length;

while (e != null) {
ThreadLocal<?> k = e.get();
if (k == key)  // 当找到当前ThreadLocal对象对应的Entry时返回结果
return e;
if (k == null)
expungeStaleEntry(i);
else
i = nextIndex(i, len); //取得hash表的下一个坐标
e = tab[i];
}
return null;
}

private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}

private T setInitialValue() {
T value = initialValue();  //上文中第一点提到的初始化方法，给要维护的变量赋初始值，可以看到，只有在调用get方法的时候，并且当前线程还未持有ThreadLocalMap实例的时候才会调用该方法，如果在get之前调用了set方法，那么当前线程就会持有一个ThreadLocalMap实例，辣么initialValue()方法将永远不会被调用。
Thread t = Thread.currentThread(); //下面几行代码类似于ThreadLocal的set方法，参看上文第二点
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}

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

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(); //该方法是Entry的超级父类java.lang.ref.Reference<T>的一个方法，该方法作用是将Entry的key设为null。
expungeStaleEntry(i); //将key为null的Entry从hash表中清除，从而完成remove功能。
return;
}
}
}

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