//在自定义类中创建ThreadLocal对象，EngineContext为我们自定义的Value对象类
//java是多线程的，父类初始化后，内部定义的ThreadLocal对象即在本线程内起效
public class ThreadLocalTest{
    private static final ThreadLocal<testContext> CONTEXT_HOLDER = new ThreadLocal<>();

    public void initalize(testContext context) {
        CONTEXT_HOLDER.set(context);
    }

    public void clean() {
        CONTEXT_HOLDER.remove();
    }

    public testContext get() {
        return CONTEXT_HOLDER.get();
    }
  ...
}

public class Thread implements Runnable {
...

    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. 
     * 与此线程相关的ThreadLocal值。由ThreadLocal类维护*/
    ThreadLocal.ThreadLocalMap threadLocals = null;

    /*
     * InheritableThreadLocal values pertaining to this thread. This map is
     * maintained by the InheritableThreadLocal class.
     * 与此线程相关的可继承父类的ThreadLocal值。由InheritableThreadLocal类维护
     */
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
...
}

...
public T get() {
  	//获取当前线程
    Thread t = Thread.currentThread();
  	//获取当前线程中的threadLocals
    ThreadLocalMap map = getMap(t);
    if (map != null) {
      	//从threadLocals中取值Entry，注意key为ThreadLocal对象本身
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

...

  public void set(T value) {
  			//获取当前线程
        Thread t = Thread.currentThread();
  			//获取当前线程中的threadLocals
        ThreadLocalMap map = getMap(t);
        if (map != null)
          	//赋值：注意key为ThreadLocal对象本身
            map.set(this, value);
        else
            createMap(t, value);
    }
...

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

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

private void set(ThreadLocal<?> key, Object value) {
    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)]) {
        ThreadLocal<?> k = e.get();

      	//如果当前遍历的ThreadLocal与传入的ThreadLocal一致，则覆盖value值
        if (k == key) {
            e.value = value;
            return;
        }

      	//如果遍历到的位置key为null，证明此处没有对象，则创建entry放入该位置
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    tab[i] = new Entry(key, value);
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

private Entry getEntry(ThreadLocal<?> key) {
  	//计算出下标
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    if (e != null && e.get() == key)
      	//匹配到相同的ThreadLocal
        return e;
    else
      	//没有匹配到相同的ThreadLocal
        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();
      
      	//找到相同的就返回，找不到就继续遍历下一个，都找不到就返回null
        if (k == key)
            return e;
        if (k == null)
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}