Java并发-ThreadLocal

public void set(T value) {
  // 获取当前线程
  Thread t = Thread.currentThread();
  // 从当前线程获取ThreadLocalMap
  ThreadLocalMap map = getMap(t);
  if (map != null)
    // map不为空设置值
    map.set(this, value);
  else
    // 初始化map
    createMap(t, value);
}

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

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

public T get() {
  Thread t = Thread.currentThread();
  // 拿到当前线程的ThreadLocalMap
  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;
    }
  }
  // 获取值时，若map为空则初始化map
  return setInitialValue();
}

private T setInitialValue() {
  // 初始化null值
  T value = initialValue();
  Thread t = Thread.currentThread();
  ThreadLocalMap map = getMap(t);
  if (map != null)
    map.set(this, value);
  else
    createMap(t, value);
  return value;
}

protected T initialValue() {
  // 初始化null值
  return null;
}

public void remove() {
  // 拿到当前Thread的`ThreadLocalMap`对象
  ThreadLocalMap m = getMap(Thread.currentThread());
  if (m != null)
    m.remove(this);
}

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

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

// 初始化容量
private static final int INITIAL_CAPACITY = 16;
// Entry数组(开放地址法处理冲突)
private Entry[] table;
// 元素个数
private int size = 0;
// 扩容阈值 table长度*2/3
private int threshold; // Default to 0
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;
  // 跟ThreadLocal的HashCode和(len-1)进行`与`操作，得到数组索引值。(需确保len为2的倍数)
  int i = key.threadLocalHashCode & (len-1);

  // 因为使用开放地址法
  // 所以需要从当前索引位置开始，不断的向后查找，直到key值相等或者遇到Entry=null值
  // 因为有阈值threshold的存在，所以不会形成死循环(肯定存在null值)
  for (Entry e = tab[i];
       e != null;
       e = tab[i = nextIndex(i, len)]) {
    ThreadLocal<?> k = e.get();

    // 找到key，更新value
    if (k == key) {
      e.value = value;
      return;
    }

    // 若key为null，此时Entry不为null，说明ThreadLocal已被回收
    if (k == null) {
      // 替换陈旧条目
      replaceStaleEntry(key, value, i);
      return;
    }
  }

  // 生成新Entry
  tab[i] = new Entry(key, value);
  // size增加
  int sz = ++size;
  // 清除数据，若没有 并且 size不小于阈值 则进行rehash
  if (!cleanSomeSlots(i, sz) && sz >= threshold)
    rehash();
}

private void rehash() {
  // 清除所有已经废弃的节点
  expungeStaleEntries();

  // Use lower threshold for doubling to avoid hysteresis
  if (size >= threshold - threshold / 4)
    // 扩容(2倍扩容)
    resize();
}

private Entry getEntry(ThreadLocal<?> key) {
  // 找到Entry[] table中的哈希索引位置
  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;

  // 直到Entry为null时，停止查找(说明该key值不存在)
  while (e != null) {
    ThreadLocal<?> k = e.get();
    // 找到key 直接返回
    if (k == key)
      return e;
    // key为null时，此时entry不为null，清除该陈旧entry
    if (k == null)
      expungeStaleEntry(i);
    else
      // key值不相等，继续查找下一个
      i = nextIndex(i, len);
    e = tab[i];
  }
  // key值不存在，返回null
  return null;
}

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) {
      // Entry清除，key置为null
      e.clear();
      // 清除key为null，entry不为null的陈旧Entry
      expungeStaleEntry(i);
      return;
    }
  }
}

ThreadLocal<SimpleDateFormat> dateFormatThreadLocal1 = new ThreadLocal<SimpleDateFormat>() {
	@Override
	protected SimpleDateFormat initialValue() {
		return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	}
};

ThreadLocal<SimpleDateFormat> dateFormatThreadLocal2 = ThreadLocal.withInitial(() ->  new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

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

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

private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {
  // ...
  // 当前线程(父线程)
  Thread parent = currentThread();
  // ...
  // 子线程拷贝父线程inheritableThreadLocals
  if (parent.inheritableThreadLocals != null)
    this.inheritableThreadLocals =  ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
  // ...
}

// 继承自ThreadLocal类

// 获取map时，返回线程的inheritableThreadLocals
ThreadLocalMap getMap(Thread t) {
  return t.inheritableThreadLocals;
}

// 创建map时，赋值给inheritableThreadLocals
void createMap(Thread t, T firstValue) {
  t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
}