private ThreadLocal<Integer> localInt = new ThreadLocal<>();
public int setAndGet(){
    localInt.set(8);
    return localInt.get();
}

private ThreadLocal<Integer> localInt = ThreadLocal.withInitial(() -> 6);

/**
 * ThreadLocals依賴于附加到每個(gè)線程的每個(gè)線程線性探測(cè)哈希映射（thread.ThreadLocals和可繼承的ThreadLocal）。
 * ThreadLocal對(duì)象充當(dāng)鍵，通過threadLocalHashCode進(jìn)行搜索。
 * 這是一個(gè)自定義哈希代碼（僅在ThreadLocalMaps中有用），在相同線程使用連續(xù)構(gòu)造的ThreadLocal的常見情況下消除了沖突，
 * 而在不常見的情況下保持良好的行為。
 */
private final int threadLocalHashCode = nextHashCode();
/**
 * 要給出的下一個(gè)哈希代碼。原子更新。從零開始。
 */
private static AtomicInteger nextHashCode = new AtomicInteger();
/**
 * 連續(xù)生成的哈希碼之間的差異-將隱式順序線程本地ID轉(zhuǎn)換為兩個(gè)大小表的冪的近似最優(yōu)的乘法哈希值。
 */
private static final int HASH_INCREMENT = 0x61c88647;
/**
 * 返回下一個(gè)哈希代碼。
 */
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}
/**
 * 設(shè)置調(diào)整大小閾值，在最壞的情況下為 2/3 負(fù)載系數(shù)
 */
private void setThreshold(int len) {
    threshold = len * 2 / 3;
}
/**
 * 根據(jù)傳入的下標(biāo)，返回下一個(gè)下標(biāo) (環(huán)形: 0-1-...-(len-1)-len-0-1-...-len)
 */
private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0);
}
/**
 * ThreadLocalMap 內(nèi)部類
 */
static class ThreadLocalMap {
    private Entry[] table;//數(shù)據(jù)數(shù)組
    private int size = 0;//數(shù)組大小
    private int threshold; //閾值
    private static final int INITIAL_CAPACITY = 16; //默認(rèn)大小
    /*
     * Entry 繼承WeakReference，并且用ThreadLocal作為key.
     * 如果key為null(entry.get() == null)，意味著key不再被引用，
     * 因此這時(shí)候entry也可以從table中清除。
     */
    static class Entry extends WeakReference<ThreadLocal<?>> {
        Object value; //存儲(chǔ)線程值
        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
    /**
    * 初始化
    */
    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        table = new Entry[INITIAL_CAPACITY];
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        table[i] = new Entry(firstKey, firstValue);
        size = 1;
        setThreshold(INITIAL_CAPACITY);
    }
}

//set 方法
public void set(T value) {
      //獲取當(dāng)前線程
      Thread t = Thread.currentThread();
      //實(shí)際存儲(chǔ)的數(shù)據(jù)結(jié)構(gòu)類型
      ThreadLocalMap map = getMap(t);
      //如果存在map就直接set，沒有則創(chuàng)建map并set
      if (map != null)
          map.set(this, value);
      else
          createMap(t, value);
  }
//getMap方法
ThreadLocalMap getMap(Thread t) {
      //thred中維護(hù)了一個(gè)ThreadLocalMap
      return t.threadLocals;
 }
//createMap
void createMap(Thread t, T firstValue) {
      //實(shí)例化一個(gè)新的ThreadLocalMap，并賦值給線程的成員變量threadLocals
      t.threadLocals = new ThreadLocalMap(this, firstValue);
}

/*
  * firstKey : 本ThreadLocal實(shí)例(this)
  * firstValue ： 要保存的線程本地變量
  */
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        //初始化table
        table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY];
        //計(jì)算索引(重點(diǎn)代碼）
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        //設(shè)置值
        table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
        size = 1;
        //設(shè)置閾值
        setThreshold(INITIAL_CAPACITY);
    }

private void set(ThreadLocal<?> key, Object value) {
        ThreadLocal.ThreadLocalMap.Entry[] tab = table;
        int len = tab.length;
        //計(jì)算索引(重點(diǎn)代碼，剛才分析過了）
        int i = key.threadLocalHashCode & (len-1);
        /**
         * 使用線性探測(cè)法查找元素（重點(diǎn)代碼）
         */
        for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
             e != null;
             e = tab[i = nextIndex(i, len)]) {
            ThreadLocal<?> k = e.get();
            //ThreadLocal 對(duì)應(yīng)的 key 存在，直接覆蓋之前的值
            if (k == key) {
                e.value = value;
                return;
            }
            // key為 null，但是值不為 null，說明之前的 ThreadLocal 對(duì)象已經(jīng)被回收了，
           // 當(dāng)前數(shù)組中的 Entry 是一個(gè)陳舊（stale）的元素
            if (k == null) {
                //用新元素替換陳舊的元素，這個(gè)方法進(jìn)行了不少的垃圾清理動(dòng)作，防止內(nèi)存泄漏
                replaceStaleEntry(key, value, i);
                return;
            }
        }
        //ThreadLocal對(duì)應(yīng)的key不存在并且沒有找到陳舊的元素，則在空元素的位置創(chuàng)建一個(gè)新的Entry。
            tab[i] = new Entry(key, value);
            int sz = ++size;
            /**
             * cleanSomeSlots用于清除那些e.get()==null的元素，
             * 這種數(shù)據(jù)key關(guān)聯(lián)的對(duì)象已經(jīng)被回收，所以這個(gè)Entry(table[index])可以被置null。
             * 如果沒有清除任何entry,并且當(dāng)前使用量達(dá)到了負(fù)載因子所定義(長(zhǎng)度的2/3)，那么進(jìn)行              * rehash（執(zhí)行一次全表的掃描清理工作）
             */
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
}
 /**
     * 獲取環(huán)形數(shù)組的下一個(gè)索引
     */
    private static int nextIndex(int i, int len) {
        return ((i + 1 < len) ? i + 1 : 0);
    }

//ThreadLocal中g(shù)et方法
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();
}
//ThreadLocalMap中g(shù)etEntry方法
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);
   }

public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }
   /**
    * Remove the entry for key.
    */
 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();//清除value
                    expungeStaleEntry(i);
                    return;
                }
            }
    }