public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
}

public T get() {
    Thread t = Thread.currentThread();//獲取當(dāng)前線程
    ThreadLocalMap map = getMap(t);//從當(dāng)前線程中獲取ThreadLocalMap
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);//獲取Entry
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;//返回對(duì)象
        }
    }
    return setInitialValue();//如果第一次調(diào)用get，ThreadLocalMap未空或者在ThreadLocalMap中還未存儲(chǔ)對(duì)象，則進(jìn)行初始化并返回存儲(chǔ)對(duì)象
  }

//移除線程所存儲(chǔ)對(duì)象
public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

static class ThreadLocalMap {
    static class Entry extends WeakReference<ThreadLocal<?>> {
        Object value;
        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
    private static final int INITIAL_CAPACITY = 16;
    private Entry[] table;
    private int size = 0;
    private int threshold; //閾值
    private void setThreshold(int len) {
            threshold = len * 2 / 3;  //負(fù)載因子是2/3,
    }
    //......省略............
}

class Test{
    byte data[]=new byte[1024*1024*10];
    @Override
    protected void finalize() throws Throwable {
        System.out.println("destroy");
    }
}
public class ThreadLocalDemo {
    public ThreadLocal<Test> t = new ThreadLocal<>();
    public static void main(String[] args) {
        ThreadLocalDemo threadLocalDemo = new ThreadLocalDemo();
        Test test = new Test();
        threadLocalDemo.t.set(test);
        test = null;
        //threadLocalDemo.t.remove();
        threadLocalDemo = null;
        System.out.println("start gc");
        System.gc();
        try {
            Thread.sleep(1000L);
        }catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("end");
    }
}

public class ThreadLocalDemo2 {
    public ThreadLocal<Test> t = new ThreadLocal<>();
	//public static ThreadLocal<Test> t = new ThreadLocal<>();
    public static void main(String[] args) {
        ThreadLocalDemo2 threadLocalDemo = new ThreadLocalDemo2();
        Test test = new Test();
        test.name = "xxxx";
        threadLocalDemo.t.set(test);
        ThreadLocalDemo2 threadLocalDemo2 = new ThreadLocalDemo2();
        Test test2 = new Test();
        test2.name = "yyyyy";
        threadLocalDemo2.t.set(test2);
        System.out.println(threadLocalDemo.t.get().name);
        System.out.println(threadLocalDemo2.t.get().name);
    }
}

private void rehash() {
    expungeStaleEntries();//清理
    if (size >= threshold - threshold / 4)//數(shù)據(jù)量仍然達(dá)到其閾值的75%，才進(jìn)行擴(kuò)容
        resize();
}
private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;
    Entry[] newTab = new Entry[newLen];//新建一個(gè)數(shù)組
    int count = 0;
    for (int j = 0; j < oldLen; ++j) {//遍歷
        Entry e = oldTab[j];
        if (e != null) {
            ThreadLocal<?> k = e.get();
            if (k == null) {
                e.value = null; //將value設(shè)為null從而幫助GC
            } else {
                //重新進(jìn)行hash
                int h = k.threadLocalHashCode & (newLen - 1);
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);//采用的時(shí)自定義hash算法
                newTab[h] = e;
                count++;
            }
        }
    }
    setThreshold(newLen);//計(jì)算新的閾值
    size = count;
    table = newTab;
}

private Entry getEntry(ThreadLocal<?> key) {
    int i = key.threadLocalHashCode & (table.length - 1);//hash運(yùn)算計(jì)算出位置
    Entry e = table[i];
    if (e != null && e.get() == key)//未發(fā)生過Hash沖突
        return e;
    else//發(fā)生過沖突
        return getEntryAfterMiss(key, i, e);//進(jìn)行下一個(gè)位置的判斷
}
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;
    while (e != null) {
        ThreadLocal<?> k = e.get();
        if (k == key)
            return e;
        if (k == null)//如果為空，則說明此位置被GC了，為過期數(shù)據(jù)
            expungeStaleEntry(i);//為了防止內(nèi)存泄漏，觸發(fā)一個(gè)“探測式”過期數(shù)據(jù)回收邏輯
        else
            i = nextIndex(i, len);//計(jì)算下一個(gè)位置
        e = tab[i];
    }
    return null;
}
//“探測式”過期數(shù)據(jù)回收邏輯
private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    tab[staleSlot].value = null;//將value設(shè)為空，幫助GC
    tab[staleSlot] = null;
    size--;
    Entry e;
    int i;
    for (i = nextIndex(staleSlot, len);//根據(jù)hash和尋址算法遍歷所有與當(dāng)前hash相同的槽點(diǎn)
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        if (k == null) {//幫助GC
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            //如果key不為空，則重新進(jìn)行hash，將其移動(dòng)到一個(gè)更靠近其hash位置的槽點(diǎn)（提高下次get的效率)
            int h = k.threadLocalHashCode & (len - 1);
            if (h != i) {
                tab[i] = null;
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}

private void set(ThreadLocal<?> key, Object value) {
	//尋址
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);
	//遍歷可能的slot
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();
		//如果key相同，則替換
        if (k == key) {
            e.value = value;
            return;
        }
		//如果k為空，則進(jìn)行取代算法
        if (k == null) {
            //大體就是遍歷可能的槽點(diǎn)，直到碰到key值相同的，則將其移動(dòng)到距離真實(shí)hash位置最近的點(diǎn)，如果沒有，則再最有好的位置new一個(gè)新的Entry
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    tab[i] = new Entry(key, value);
    int sz = ++size;//判斷是否達(dá)到擴(kuò)容條件
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}