/**
 * ThreadLocal 中保存的數(shù)據(jù)是 Map
 */
static final ThreadLocal<Map<String, String>> context = new ThreadLocal<>();
@Test
public void testThread() {
  // 從上下文中拿出 Map
  Map<String, String> contextMap = context.get();
  if (CollectionUtils.isEmpty(contextMap)) {
    contextMap = Maps.newHashMap();
  }
  contextMap.put("key1", "value1");
  context.set(contextMap);
  log.info("key1，value1被放到上下文中");
	// 從上下文中拿出剛才放進去的數(shù)據(jù)
  getFromComtext();
}
private String getFromComtext() {
  String value1 = context.get().get("key1");
  log.info("從 ThreadLocal 中取出上下文，key1 對應的值為：{}", value1);
  return value1;
}
//運行結(jié)果:
demo.ninth.ThreadLocalDemo - key1，value1被放到上下文中
demo.ninth.ThreadLocalDemo - 從 ThreadLocal 中取出上下文，key1 對應的值為：value1

public class ThreadLocal<T> {}

// threadLocalHashCode 表示當前 ThreadLocal 的 hashCode，用于計算當前 ThreadLocal 在 ThreadLocalMap 中的索引位置
private final int threadLocalHashCode = nextHashCode();
// 計算 ThreadLocal 的 hashCode 值(就是遞增)
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}
// static + AtomicInteger 保證了在一臺機器中每個 ThreadLocal 的 threadLocalHashCode 是唯一的
// 被 static 修飾非常關(guān)鍵，因為一個線程在處理業(yè)務的過程中，ThreadLocalMap 是會被 set 多個 ThreadLocal 的，多個 ThreadLocal 就依靠 threadLocalHashCode 進行區(qū)分
private static AtomicInteger nextHashCode = new AtomicInteger();

// threadLocalHashCode 表示當前 ThreadLocal 的 hashCode，用于計算當前 ThreadLocal 在 ThreadLocalMap 中的索引位置
private final int threadLocalHashCode = nextHashCode();
// 計算 ThreadLocal 的 hashCode 值(就是遞增)
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}
// static + AtomicInteger 保證了在一臺機器中每個 ThreadLocal 的 threadLocalHashCode 是唯一的
// 被 static 修飾非常關(guān)鍵，因為一個線程在處理業(yè)務的過程中，ThreadLocalMap 是會被 set 多個 ThreadLocal 的，多個 ThreadLocal 就依靠 threadLocalHashCode 進行區(qū)分
private static AtomicInteger nextHashCode = new AtomicInteger();

// set 操作每個線程都是串行的，不會有線程安全的問題
public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    // 當前 thradLocal 之前有設置值，直接設置，否則初始化
    if (map != null)
        map.set(this, value);
    // 初始化ThreadLocalMap
    else
        createMap(t, value);
}

private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    int len = tab.length;
    // 計算 key 在數(shù)組中的下標，其實就是 ThreadLocal 的 hashCode 和數(shù)組大小-1取余
    int i = key.threadLocalHashCode & (len-1);
 
    // 整體策略：查看 i 索引位置有沒有值，有值的話，索引位置 + 1，直到找到?jīng)]有值的位置
    // 這種解決 hash 沖突的策略，也導致了其在 get 時查找策略有所不同，體現(xiàn)在 getEntryAfterMiss 中
    for (Entry e = tab[i];
         e != null;
         // nextIndex 就是讓在不超過數(shù)組長度的基礎上，把數(shù)組的索引位置 + 1
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();
        // 找到內(nèi)存地址一樣的 ThreadLocal，直接替換
        if (k == key) {
            e.value = value;
            return;
        }
        // 當前 key 是 null，說明 ThreadLocal 被清理了，直接替換掉
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    // 當前 i 位置是無值的，可以被當前 thradLocal 使用
    tab[i] = new Entry(key, value);
    int sz = ++size;
    // 當數(shù)組大小大于等于擴容閾值(數(shù)組大小的三分之二)時，進行擴容
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

public T get() {
    // 因為 threadLocal 屬于線程的屬性，所以需要先把當前線程拿出來
    Thread t = Thread.currentThread();
    // 從線程中拿到 ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        // 從 map 中拿到 entry，由于 ThreadLocalMap 在 set 時的 hash 沖突的策略不同，導致拿的時候邏輯也不太一樣
        ThreadLocalMap.Entry e = map.getEntry(this);
        // 如果不為空，讀取當前 ThreadLocal 中保存的值
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 否則給當前線程的 ThreadLocal 初始化，并返回初始值 null
    return setInitialValue();
}

// 得到當前 thradLocal 對應的值，值的類型是由 thradLocal 的泛型決定的
// 由于 thradLocalMap set 時解決數(shù)組索引位置沖突的邏輯，導致 thradLocalMap get 時的邏輯也是對應的
// 首先嘗試根據(jù) hashcode 取模數(shù)組大小-1 = 索引位置 i 尋找，找不到的話，自旋把 i+1，直到找到索引位置不為空為止
private Entry getEntry(ThreadLocal<?> key) {
    // 計算索引位置：ThreadLocal 的 hashCode 取模數(shù)組大小-1
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    // e 不為空，并且 e 的 ThreadLocal 的內(nèi)存地址和 key 相同，直接返回，否則就是沒有找到，繼續(xù)通過 getEntryAfterMiss 方法找
    if (e != null && e.get() == key)
        return e;
    else
    // 這個取數(shù)據(jù)的邏輯，是因為 set 時數(shù)組索引位置沖突造成的  
        return getEntryAfterMiss(key, i, e);
}

// 自旋 i+1，直到找到為止
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;
    // 在大量使用不同 key 的 ThreadLocal 時，其實還蠻耗性能的
    while (e != null) {
        ThreadLocal<?> k = e.get();
        // 內(nèi)存地址一樣，表示找到了
        if (k == key)
            return e;
        // 刪除沒用的 key
        if (k == null)
            expungeStaleEntry(i);
        // 繼續(xù)使索引位置 + 1
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

//擴容
private void resize() {
    // 拿出舊的數(shù)組
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    // 新數(shù)組的大小為老數(shù)組的兩倍
    int newLen = oldLen * 2;
    // 初始化新數(shù)組
    Entry[] newTab = new Entry[newLen];
    int count = 0;
    // 老數(shù)組的值拷貝到新數(shù)組上
    for (int j = 0; j < oldLen; ++j) {
        Entry e = oldTab[j];
        if (e != null) {
            ThreadLocal<?> k = e.get();
            if (k == null) {
                e.value = null; // Help the GC
            } else {
                // 計算 ThreadLocal 在新數(shù)組中的位置
                int h = k.threadLocalHashCode & (newLen - 1);
                // 如果索引 h 的位置值不為空，往后+1，直到找到值為空的索引位置
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                // 給新數(shù)組賦值
                newTab[h] = e;
                count++;
            }
        }
    }
    // 給新數(shù)組初始化下次擴容閾值，為數(shù)組長度的三分之二
    setThreshold(newLen);
    size = count;
    table = newTab;
}