public class TestThreadLocal {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public static void main(String[] args) {
        TestThreadLocal testThreadLocal = new TestThreadLocal();
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    testThreadLocal.setName(Thread.currentThread().getName() + "的信息");
                    System.out.println(Thread.currentThread().getName() + ": " + testThreadLocal.getName());
                }
            }).start();
        }
    }
}

public class TestThreadLocal {
    private static ThreadLocal<String> t = new ThreadLocal<>();
    private String name;
    public String getName() {
        return t.get();
    }
    public void setName(String name) {
        t.set(name);
    }
    public static void main(String[] args) {
        TestThreadLocal testThreadLocal = new TestThreadLocal();
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    testThreadLocal.setName(Thread.currentThread().getName() + "的信息");
                    System.out.println(Thread.currentThread().getName() + ": " + testThreadLocal.getName());
                }
            }).start();
        }
    }
}

public class Thread implements Runnable {
    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;
}
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;
            }
        }
}

    public void set(T value) {    
        //獲取當前線程
        Thread t = Thread.currentThread();
        //獲取threalLocals
        ThreadLocalMap map = getMap(t);
        //將ThreadLocal和值一起存入當前線程的ThreadLocalMap中
        if (map != null)
            //如果存在就調用map.set()，這里的this指的是調用此方法的ThreadLocal對象
            map.set(this, value);
        else
            createMap(t, value);
    }
    //獲取當前線程維護的ThreadLocalMap
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
    //創(chuàng)建當前線程
    void createMap(Thread t, T firstValue) {
        //這里的this是調用此方法的threadLocal
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

    public T get() {
        //獲取當前線程
        Thread t = Thread.currentThread();
        //拿到threadLocals字段
        ThreadLocalMap map = getMap(t);
        //如果map存在
        if (map != null) {
            //獲取對應的存儲實體
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                //獲取存儲尸體對應的value值
                T result = (T)e.value;
                return result;
            }
        }
        //執(zhí)行當前代碼的兩種情況：1、map不存在，說明此線程沒有ThreadLocalMap對象；2、map存在，但是沒有與當前ThreadLocal關聯的Entry
        return setInitialValue();
    }
    private T setInitialValue() {
        // 調用initialValue獲取初始化的值
        // 此方法可以被子類重寫, 如果不重寫默認返回null
        T value = initialValue();
        // 獲取當前線程對象
        Thread t = Thread.currentThread();
        // 獲取此線程對象中維護的ThreadLocalMap對象
        ThreadLocalMap map = getMap(t);
        // 判斷map是否存在
        if (map != null)
            // 存在則調用map.set設置此實體entry
            map.set(this, value);
        else
            // 1）當前線程Thread 不存在ThreadLocalMap對象
            // 2）則調用createMap進行ThreadLocalMap對象的初始化
            // 3）并將 t(當前線程)和value(t對應的值)作為第一個entry存放至ThreadLocalMap中
            createMap(t, value);
        // 返回設置的值value
        return value;
    }

     public void remove() {
        // 獲取當前線程對象中維護的ThreadLocalMap對象
         ThreadLocalMap m = getMap(Thread.currentThread());
        // 如果此map存在
         if (m != null)
            // 存在則調用map.remove
            // 以當前ThreadLocal為key刪除對應的實體entry
             m.remove(this);
     }

/**
  * 返回當前線程對應的ThreadLocal的初始值
  * 此方法的第一次調用發(fā)生在，當線程通過get方法訪問此線程的ThreadLocal值時
  * 除非線程先調用了set方法，在這種情況下，initialValue 才不會被這個線程調用。
  * 通常情況下，每個線程最多調用一次這個方法。
  *
  * <p>這個方法僅僅簡單的返回null {@code null};
  * 如果想ThreadLocal線程局部變量有一個除null以外的初始值，
  * 必須通過子類繼承{@code ThreadLocal} 的方式去重寫此方法
  * 通常, 可以通過匿名內部類的方式實現
  *
  * @return 當前ThreadLocal的初始值
  */
protected T initialValue() {
    return null;
}

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

    private final int threadLocalHashCode = nextHashCode();
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }
//AtomicInteger是一個提供原子操作的Integer類，通過線程安全的方式操作加減,適合高并發(fā)情況下的使用
    private static AtomicInteger nextHashCode =  new AtomicInteger();
     //特殊的hash值
    private static final int HASH_INCREMENT = 0x61c88647;

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

ThreadLocal<String> threadLocal = new ThreadLocal();
try {
    threadLocal.set("xxx");
    // ...
} finally {
    threadLocal.remove();
}