問題:在多線程環境下，如何防止自己的變數被其它線程篡改

答案:ThreadLocal.

ThreadLocal 不是用來解決共用對象的多線程訪問的競爭問題的，因為ThreadLocal.set() 到線程中的對象是該線程自己使用的對象，其他線程是不需要訪問的，也訪問不到的。當線程終止後，這些值會作為垃圾回收。

ThreadLocal的作用是提供線程內的局部變數，這種變數線上程的生命周期內起作用。作用：提供一個線程內公共變數（比如本次請求的用戶信息），減少同一個線程內多個函數或者組件之間一些公共變數的傳遞的複雜度，或者為線程提供一個私有的變數副本，這樣每一個線程都可以隨意修改自己的變數副本，而不會對其他線程產生影響。

ThreadLocal簡介

ThreadLocal，很多地方叫做線程本地變數，也有些地方叫做線程本地存儲，其實意思差不多。可能很多朋友都知道ThreadLocal為變數在每個線程中都創建了一個副本，那麼每個線程可以訪問自己內部的副本變數。

ThreadLocal 用一種存儲變數與線程綁定的方式，在每個線程中用自己的 ThreadLocalMap 安全隔離變數，如為每個線程創建一個獨立的資料庫連接。因為是與線程綁定的，所以在很多場景也被用來實現線程參數傳遞，如 Spring 的 RequestContextHolder。也因為每個線程擁有自己唯一的 ThreadLocalMap ，所以 ThreadLocalMap 是天然線程安全的。

ThreadLocal 存儲結構

首先我們來聊一聊 ThreadLocal 在多線程運行時，各線程是如何存儲變數的，假如我們現在定義兩個 ThreadLocal 實例如下：

static ThreadLocal<User> threadLocal_1 = new ThreadLocal<>();
static ThreadLocal<Client> threadLocal_2 = new ThreadLocal<>();

我們分別在三個線程中使用 ThreadLocal，偽代碼如下：

// thread-1中
threadLocal_1.set(user_1);
threadLocal_2.set(client_1);

// thread-2中
threadLocal_1.set(user_2);
threadLocal_2.set(client_2);

// thread-3中
threadLocal_2 .set(client_3);

這三個線程都在運行中，那此時各線程中的存數數據應該如下圖所示：

ThreadLocal用法

ThreadLocal用於保存某個線程共用變數：對於同一個static ThreadLocal，不同線程只能從中get，set，remove自己的變數，而不會影響其他線程的變數。

1、ThreadLocal.get: 獲取ThreadLocal中當前線程共用變數的值。

2、ThreadLocal.set: 設置ThreadLocal中當前線程共用變數的值。

3、ThreadLocal.remove: 移除ThreadLocal中當前線程共用變數的值。

4、ThreadLocal.initialValue: ThreadLocal沒有被當前線程賦值時或當前線程剛調用remove方法後調用get方法，返回此方法值。

public T get() { }  
public void set(T value) { }  
public void remove() { }  
protected T initialValue() { } 

get()方法是用來獲取ThreadLocal在當前線程中保存的變數副本，

set()用來設置當前線程中變數的副本，

remove()用來移除當前線程中變數的副本，

initialValue()是一個protected方法，一般是用來在使用時進行重寫的，它是一個延遲載入方法，下麵會詳細說明。

get()方法

/**
 * Returns the value in the current thread's copy of this
 * thread-local variable.  If the variable has no value for the
 * current thread, it is first initialized to the value returned
 * by an invocation of the {@link #initialValue} method.
 *
 * @return the current thread's value of this thread-local
 */
public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        //調用  ThreadLocalMap 的 getEntry 方法
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 如果還沒有設置，可以用子類重寫initialValue,自定義初始值。
    return setInitialValue();
}

第一句是取得當前線程，

然後通過getMap(t)方法獲取到一個map，map的類型為ThreadLocalMap。

然後接著下麵獲取到<key,value>鍵值對，註意這裡獲取鍵值對傳進去的是 this(當前threadLocal對象)，而不是當前線程t。

如果獲取成功，則返回value值。

如果map為空，則調用setInitialValue方法返回value。

我們上面的每一句來仔細分析：

首先看一下getMap方法中做了什麼：

/**
 * Get the map associated with a ThreadLocal. Overridden in
 * InheritableThreadLocal.
 *
 * @param  t the current thread
 * @return the map
 */
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

可能大家沒有想到的是，在getMap中，是調用當期線程t，返回當前線程t中的一個成員變數threadLocals。

那麼我們繼續取Thread類中取看一下成員變數threadLocals是什麼：

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

實際上就是一個ThreadLocalMap，這個類型是ThreadLocal類的一個內部類，

我們繼續取看ThreadLocalMap的實現：

/**
 * ThreadLocalMap is a customized hash map suitable only for
 * maintaining thread local values. No operations are exported
 * outside of the ThreadLocal class. The class is package private to
 * allow declaration of fields in class Thread.  To help deal with
 * very large and long-lived usages, the hash table entries use
 * WeakReferences for keys. However, since reference queues are not
 * used, stale entries are guaranteed to be removed only when
 * the table starts running out of space.
 */
static class ThreadLocalMap {
 
  /**
  * The entries in this hash map extend WeakReference, using
  * its main ref field as the key (which is always a
  * ThreadLocal object).  Note that null keys (i.e. entry.get()
  * == null) mean that the key is no longer referenced, so the
  * entry can be expunged from table.  Such entries are referred to
  * as "stale entries" in the code that follows.
  */
  static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

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

可以看到ThreadLocalMap的Entry繼承了WeakReference，並且使用ThreadLocal作為鍵。

然後再繼續看setInitialValue方法的具體實現：

/**
 * Variant of set() to establish initialValue. Used instead
 * of set() in case user has overridden the set() method.
 *
 * @return the initial value
 */
private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

很容易瞭解，就是如果map不為空，就設置鍵值對，為空，再創建Map，

看一下createMap的實現：

/**
* Create the map associated with a ThreadLocal. Overridden in
* InheritableThreadLocal.
*
* @param t the current thread
* @param firstValue value for the initial entry of the map
*/
void createMap(Thread t, T firstValue) {
  t.threadLocals = new ThreadLocalMap(this, firstValue);
}

至此，可能大部分朋友已經明白了ThreadLocal是如何為每個線程創建變數的副本的：

    首先，在每個線程Thread內部有一個ThreadLocal.ThreadLocalMap類型的成員變數threadLocals，這個threadLocals就是用來存儲實際的變數副本的，鍵為當前ThreadLocal變數，value為變數副本（即T類型的變數,傳入的參數）。

    初始時，在Thread裡面，threadLocals為空，當通過ThreadLocal變數調用get()方法或者set()方法，就會對Thread類中的threadLocals進行初始化，並且以當前ThreadLocal變數為鍵值，以ThreadLocal要保存的副本變數為value，存到threadLocals。

    然後在當前線程裡面，如果要使用副本變數，就可以通過get方法在threadLocals裡面查找。

​ 下麵通過一個例子來證明通過ThreadLocal能達到在每個線程中創建變數副本的效果：

package com.milo.jdk.lang;
/**
 * You need to setting before getting it, otherwise there will be a NullPointerException
 * @author MILO
 *
 */
public class MiloTheadLocal {
  ThreadLocal<Long> longLocal = new ThreadLocal<Long>();  
  ThreadLocal<String> stringLocal = new ThreadLocal<String>();  

  public void set() {  
    longLocal.set(Thread.currentThread().getId());
    stringLocal.set(Thread.currentThread().getName());
  }  

  public long getLong() {  
    return longLocal.get();  
  }  

  public String getString() {  
    return stringLocal.get();  
  }  

  public static void main(String[] args) throws InterruptedException {  
    final MiloTheadLocal test = new MiloTheadLocal();  

    test.set();  
    System.out.println(test.getLong());  
    System.out.println(test.getString());  


    Thread thread=new Thread() {
      public void run() {
        test.set();
        System.out.println(test.getLong());  
        System.out.println(test.getString());  
      }
    };
    thread.start();
    //thread.join():用來指定當前主線程等待其他線程執行完畢後,再來繼續執行Thread.join()後面的代碼
    thread.join();
    System.out.println(test.getLong());  
    System.out.println(test.getString());  
  }  
}

運行結果：

1
main
10
Thread-0
1
main

從這段代碼的輸出結果可以看出，在main線程中和thread1線程中，longLocal保存的副本值和stringLocal保存的副本值都不一樣。最後一次在main線程再次列印副本值是為了證明在main線程中和thread1線程中的副本值確實是不同的。

總結一下：

    1）實際的通過ThreadLocal創建的副本是存儲在每個線程自己的threadLocals中的；

    2）為何threadLocals的類型ThreadLocalMap的鍵值為ThreadLocal對象，因為每個線程中可有多個threadLocal變數，就像上面代碼中的longLocal和stringLocal；

    3）在進行get之前，必須先set，否則會報空指針異常；

如果想在get之前不需要調用set就能正常訪問的話，必須重寫initialValue()方法。

因為在上面的代碼分析過程中，我們發現如果沒有先set的話，即在map中查找不到對應的存儲，則會通過調用setInitialValue方法返回i，而在setInitialValue方法中，有一個語句是T value = initialValue()， 而預設情況下，initialValue方法返回的是null。

/**
* Returns the value in the current thread's copy of this
* thread-local variable.  If the variable has no value for the
* current thread, it is first initialized to the value returned
* by an invocation of the {@link #initialValue} method.
*
* @return the current thread's value of this thread-local
*/
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();
}

/**
* Variant of set() to establish initialValue. Used instead
* of set() in case user has overridden the set() method.
*
* @return the initial value
*/
private T setInitialValue() {
  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() {
    return null;
}

看下麵這個例子,把初始的set()方法屏蔽掉,會報空指針異常：

package com.milo.jdk.lang;
/**
 * You need to setting before getting it, otherwise there will be a NullPointerException
 * @author MILO
 *
 */
public class MiloTheadLocal {
  ThreadLocal<Long> longLocal = new ThreadLocal<Long>();  
  ThreadLocal<String> stringLocal = new ThreadLocal<String>();  

  public void set() {  
    longLocal.set(Thread.currentThread().getId());
    stringLocal.set(Thread.currentThread().getName());
  }  

  public long getLong() {  
    return longLocal.get();  
  }  

  public String getString() {  
    return stringLocal.get();  
  }  

  public static void main(String[] args) throws InterruptedException {  
    final MiloTheadLocal test = new MiloTheadLocal();  

    //test.set();  
    System.out.println(test.getLong());  
    System.out.println(test.getString());  


    Thread thread=new Thread() {
      public void run() {
        test.set();
        System.out.println(test.getLong());  
        System.out.println(test.getString());  
      }
    };
    thread.start();
    //thread.join():用來指定當前主線程等待其他線程執行完畢後,再來繼續執行Thread.join()後面的代碼
    thread.join();
    System.out.println(test.getLong());  
    System.out.println(test.getString());  
  }  
}

運行結果：

Exception in thread "main" java.lang.NullPointerException
    at com.milo.jdk.lang.MiloTheadLocal.getLong(MiloTheadLocal.java:17)
    at com.milo.jdk.lang.MiloTheadLocal.main(MiloTheadLocal.java:28)

在main線程中，沒有先set，直接get的話，運行時會報空指針異常。

但是如果改成下麵這段代碼，即重寫了initialValue方法：

package com.milo.jdk.lang;
/**
 * You not need to setting before getting it.
 * @author MILO
 *
 */
public class MiloTheadLocal2 {
  ThreadLocal<Long> longLocal = new ThreadLocal<Long>() {  
    //重寫initialValue方法,進行賦值,此後可以不使用set方法且不報錯
    @Override
    protected Long initialValue() {  
      return Thread.currentThread().getId();  
    };  
  };  

  ThreadLocal<String> stringLocal = new ThreadLocal<String>() {  
    protected String initialValue() {  
      return Thread.currentThread().getName();  
    };  
  };  

  public void set() {  
    longLocal.set(Thread.currentThread().getId());  
    stringLocal.set(Thread.currentThread().getName());  
  }  

  public long getLong() {  
    return longLocal.get();  
  }  

  public String getString() {  
    return stringLocal.get();  
  }  

  public static void main(String[] args) throws InterruptedException {  
    final MiloTheadLocal2 test = new MiloTheadLocal2();  

    //test.set();  
    System.out.println(test.getLong());  
    System.out.println(test.getString());  

    Thread thread1 = new Thread() {  
      public void run() {  
        //test.set();  
        System.out.println(test.getLong());  
        System.out.println(test.getString());  
      };  
    };  
    thread1.start();  
    thread1.join();  

    System.out.println(test.getLong());  
    System.out.println(test.getString());  
  }  
}

運行結果：

1  
main  
8  
Thread-0  
1  
main  

此時重寫了initialValue方法,就算不用set方法,也不會報空指針錯誤了,因為在重寫的過程中,已經提前賦值了

ThreadLocalMap核心方法

1.如何實現一個線程多個ThreadLocal對象，每一個ThreadLocal對象是如何區分的呢？

答案:ThreadLocalMap 之 key 的 hashCode 計算

查看源碼，可以看到：

private final int threadLocalHashCode = nextHashCode();
private static AtomicInteger nextHashCode = new AtomicInteger();
private static final int HASH_INCREMENT = 0x61c88647;
private static int nextHashCode() {
      return nextHashCode.getAndAdd(HASH_INCREMENT);
}

　　對於每一個ThreadLocal對象，都有一個final修飾的int型的threadLocalHashCode不可變屬性，對於基本數據類型，可以認為它在初始化後就不可以進行修改，所以可以唯一確定一個ThreadLocal對象。
　　但是如何保證兩個同時實例化的ThreadLocal對象有不同的threadLocalHashCode屬性：

在ThreadLocal類中，還包含了一個static修飾的AtomicInteger（[əˈtɒmɪk]提供原子操作的Integer類）成員變數（即類變數）和一個static final修飾的常量（作為兩個相鄰nextHashCode的差值）。

由於nextHashCode是類變數，所以每一次調用ThreadLocal類都可以保證nextHashCode被更新到新的值，並且下一次調用ThreadLocal類這個被更新的值仍然可用，同時AtomicInteger保證了nextHashCode自增的原子性。

這裡寫個demo看一下基於這種方式產生的hash分佈多均勻：

public class ThreadLocalTest {

    public static void main(String[] args) {
        printAllSlot(8);
        printAllSlot(16);
        printAllSlot(32);
    }

    static void printAllSlot(int len) {
        System.out.println("********** len = " + len + " ************");
        for (int i = 1; i <= 64; i++) {
            ThreadLocal<String> t = new ThreadLocal<>();
            int slot = getSlot(t, len);
            System.out.print(slot + " ");
            if (i % len == 0)
                System.out.println(); // 分組換行
        }
    }

    /**
     * 獲取槽位
     * 
     * @param t ThreadLocal
     * @param len 模擬map的table的length
     * @throws Exception
     */
    static int getSlot(ThreadLocal<?> t, int len) {
        int hash = getHashCode(t);
        return hash & (len - 1);
    }

    /**
     * 反射獲取 threadLocalHashCode 欄位，因為其為private的
     */
    static int getHashCode(ThreadLocal<?> t) {
        Field field;
        try {
            field = t.getClass().getDeclaredField("threadLocalHashCode");
            field.setAccessible(true);
            return (int) field.get(t);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }
}

上述代碼模擬了 ThreadLocal 做為 key 的hashCode產生，看看完美槽位分配：
********** len = 8 ************
2 1 0 7 6 5 4 3 
2 1 0 7 6 5 4 3 
2 1 0 7 6 5 4 3 
2 1 0 7 6 5 4 3 
2 1 0 7 6 5 4 3 
2 1 0 7 6 5 4 3 
2 1 0 7 6 5 4 3 
2 1 0 7 6 5 4 3 
********** len = 16 ************
10 1 8 15 6 13 4 11 2 9 0 7 14 5 12 3 
10 1 8 15 6 13 4 11 2 9 0 7 14 5 12 3 
10 1 8 15 6 13 4 11 2 9 0 7 14 5 12 3 
10 1 8 15 6 13 4 11 2 9 0 7 14 5 12 3 
********** len = 32 ************
10 17 24 31 6 13 20 27 2 9 16 23 30 5 12 19 26 1 8 15 22 29 4 11 18 25 0 7 14 21 28 3 
10 17 24 31 6 13 20 27 2 9 16 23 30 5 12 19 26 1 8 15 22 29 4 11 18 25 0 7 14 21 28 3

解釋:

​ 傳入數組長度8(既main方法中的數字8),則會產生[0,7]8個值,對應數組下標

​ 傳入數組長度16(既main方法中的數字16),則會產生[0,15]16個值,對應數組下標

​ 傳入數組長度32(既main方法中的數字32),則會產生[0,31]32個值,對應數組下標

為什麼不直接用線程id來作為ThreadLocalMap的key？

　　這一點很容易理解，因為直接用線程id來作為ThreadLocalMap的key，無法區分放入ThreadLocalMap中的多個value。比如我們放入了兩個字元串，你如何知道我要取出來的是哪一個字元串呢？
　　而使用ThreadLocal作為key就不一樣了，由於每一個ThreadLocal對象都可以由threadLocalHashCode屬性唯一區分或者說每一個ThreadLocal對象都可以由這個對象的名字唯一區分，所以可以用不同的ThreadLocal作為key，區分不同的value，方便存取。

2.ThreadLocalMap 之 set() 方法

private void set(ThreadLocal<?> key, Object value) {

    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1); // 用key的hashCode計算槽位
    // hash衝突時，使用開放地址法
    // 因為獨特和hash演算法，導致hash衝突很少，一般不會走進這個for迴圈
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();

        if (k == key) { // key 相同，則覆蓋value
            e.value = value; 
            return;
        }

        if (k == null) { // key = null，說明 key 已經被回收了，進入替換方法
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    // 新增 Entry
    tab[i] = new Entry(key, value);
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold) // 清除一些過期的值，並判斷是否需要擴容
        rehash(); // 擴容
}

這個 set 方法涵蓋了很多關鍵點：

1. 開放地址法：與我們常用的Map不同，java里大部分Map都是用鏈表發解決hash衝突的，而 ThreadLocalMap 採用的是開發地址法。
2. hash演算法：hash值演算法的精妙之處上面已經講了，均勻的 hash 演算法使其可以很好的配合開方地址法使用；
3. 過期值清理：關於過期值的清理是網上討論比較多了，因為只要有關於可能記憶體溢出的話題，就會帶來很多噱頭和流量。

簡單介紹一下開放地址法和鏈表法：

開放地址法：容易產生堆積問題；不適於大規模的數據存儲；散列函數的設計對衝突會有很大的影響；插入時可能會出現多次衝突的現象，刪除的元素是多個衝突元素中的一個，需要對後面的元素作處理，實現較複雜；結點規模很大時會浪費很多空間；

鏈地址法：處理衝突簡單，且無堆積現象，平均查找長度短；鏈表中的結點是動態申請的，適合構造表不能確定長度的情況；相對而言，拉鏈法的指針域可以忽略不計，因此較開放地址法更加節省空間。插入結點應該在鏈首，刪除結點比較方便，只需調整指針而不需要對其他衝突元素作調整。

ThreadLocalMap 為什麼採用開放地址法？

個人認為由於 ThreadLocalMap 的 hashCode 的精妙設計，使hash衝突很少，並且 Entry 繼承 WeakReference， 很容易被回收，並開方地址可以節省一些指針空間；然而恰恰由於開方地址法的使用，使在處理hash衝突時的代碼很難懂，比如在replaceStaleEntry,cleanSomeSlots，expungeStaleEntry 等地方，然而真正調用這些方法的幾率卻比較小；要把上述方法搞清楚，最好畫一畫開方地址法發生hash衝突的狀態圖，容易理解一點，本文不詳細探討。

下麵對 set 方法裡面的幾個關鍵方法展開：

a. replaceStaleEntry
因為開發地址發的使用，導致 replaceStaleEntry 這個方法有些複雜，它的清理工作會涉及到slot前後的非null的slot。

private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                               int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    // 往前尋找過期的slot
    int slotToExpunge = staleSlot;
    for (int i = prevIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;

    // 找到 key 或者 直到 遇到null 的slot 才終止迴圈
    for (int i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();

        // 如果找到了key，那麼需要將它與過期的 slot 交換來維護哈希表的順序。
        // 然後可以將新過期的 slot 或其上面遇到的任何其他過期的 slot 
        // 給 expungeStaleEntry 以清除或 rehash 這個 run 中的所有其他entries。

        if (k == key) {
            e.value = value;

            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;

            // 如果存在，則開始清除前面過期的entry
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        // 如果我們沒有在向前掃描中找到過期的條目，
        // 那麼在掃描 key 時看到的第一個過期 entry 是仍然存在於 run 中的條目。
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // 如果沒有找到 key，那麼在 slot 中創建新entry
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);

    // 如果還有其他過期的entries存在 run 中，則清除他們
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

上文中的 run 不好翻譯，理解為開放地址中一個slot中前後不為null的連續entry

b.cleanSomeSlots
cleanSomeSlots 清除一些slot（一些？是不是有點模糊，到底是哪些？）

private boolean cleanSomeSlots(int i, int n) {
    boolean removed = false;
    Entry[] tab = table;
    int len = tab.length;
    do {
        i = nextIndex(i, len);
        Entry e = tab[i];
        if (e != null && e.get() == null) {
            n = len;
            removed = true;
            i = expungeStaleEntry(i); // 清除方法 
        }
    } while ( (n >>>= 1) != 0);  // n = n / 2， 對數控制迴圈 
    return removed;
}

當新元素被添加時，或者另一個過期元素已被刪除時，會調用cleanSomeSlots。該方法會試探性地掃描一些 entry 尋找過期的條目。它執行 對數 數量的掃描，是一種 基於不掃描（快速但保留垃圾）和 所有元素掃描之間的平衡。

上面說到的對數數量是多少？迴圈次數 = log2(N) （log以2為底N的對數），此處N是map的size，如：

log2（4） = 2
log2（5） = 2
log2（18） = 4

因此，此方法並沒有真正的清除，只是找到了要清除的位置，而真正的清除在 expungeStaleEntry(int staleSlot) 裡面

c.expungeStaleEntry(int staleSlot)

這裡是真正的清除，並且不要被方法名迷惑，不僅僅會清除當前過期的slot，還回往後查找直到遇到null的slot為止。開發地址法的清除也較難理解，清除當前slot後還有往後進行rehash。

private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;

    // 清除當前過期的slot
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;

    // Rehash 直到 null 的 slot
    Entry e;
    int i;
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        if (k == null) {
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            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;
}

3. ThreadLocalMap 之 getEntry() 方法

getEntry() 主要是在 ThreadLocal 的 get() 方法里被調用

private Entry getEntry(ThreadLocal<?> key) {
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    if (e != null && e.get() == key) // 無hash衝突情況
        return e;
    else
        return getEntryAfterMiss(key, i, e); // 有hash衝突情況
}

該方法比較簡潔，首先運算槽位 i ，然後判斷 table[i] 是否是目標entry，不是則進入 getEntryAfterMiss(key, i, e)；

下麵展開 getEntryAfterMiss 方法：

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)
            expungeStaleEntry(i); // 此方法上面已經講過了
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

這個方法是在遇到 hash 衝突時往後繼續查找，並且會清除查找路上遇到的過期slot。

4. ThreadLocalMap 之 rehash() 方法

private void rehash() {
    expungeStaleEntries();

   // 在上面的清除過程中，size會減小，在此處重新計算是否需要擴容
   // 並沒有直接使用threshold，而是用較低的threshold （約 threshold 的 3/4）提前觸發resize
    if (size >= threshold - threshold / 4)
        resize();
}

private void expungeStaleEntries() {
    Entry[] tab = table;
    int len = tab.length;
    for (int j = 0; j < len; j++) {
        Entry e = tab[j];
        if (e != null && e.get() == null)
            expungeStaleEntry(j);
    }
}

rehash() 里首先調用 expungeStaleEntries()，然後迴圈調用 expungeStaleEntry(j) ,此方法會清除所有過期的slot。

繼續看 resize()：

private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;
    Entry[] newTab = new Entry[newLen];
    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; // Help the GC
            } else {
                int h = k.threadLocalHashCode & (newLen - 1);
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                count++;
            }
        }
    }

    setThreshold(newLen);
    size = count;
    table = newTab;
}

resize() 方法里也會過濾掉一些 過期的 entry。

PS :ThreadLocalMap 沒有 影響因數 的欄位，是採用直接設置 threshold 的方式，threshold = len * 2 / 3，相當於不可修改的影響因數為 2/3，比 HashMap 的預設 0.75 要低。這也是減少hash衝突的方式。

5. ThreadLocalMap 之 remove(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();
            expungeStaleEntry(i);
            return;
        }
    }
}

remove 方法是刪除特定的 ThreadLocal，建議在 ThreadLocal 使用完後執行此方法。

總結

一、ThreadLocalMap 的 value 清理觸發時間：

1. set(ThreadLocal<?> key, Object value)
   若無hash衝突，則先向後檢測log2(N)個位置，發現過期 slot 則清除，如果沒有任何 slot 被清除，則判斷 size >= threshold，超過閥值會進行 rehash()，rehash()會清除所有過期的value；
2. getEntry(ThreadLocal<?> key) (ThreadLocal 的 get() 方法調用)
   如果沒有直接在hash計算的 slot 中找到entry， 則需要向後繼續查找(直到null為止)，查找期間發現的過期 slot 會被清除；
3. remove(ThreadLocal<?> key)
   remove 不僅會清除需要清除的 key，還是清除hash衝突的位置的已過期的 key；

清晰了以上過程，相信對於 ThreadLocal 的 記憶體溢出問題會有自己的看法。在實際開發中，不應亂用 ThreadLocal ，如果使用 ThreadLocal 發生了記憶體溢出，那應該考慮是否使用合理。

PS：這裡的清除並不代表被回收，只是把 value 置為 null，value 的具體回收時間由 垃圾收集器 決定。

二、ThreadLocalMap 的 hash 演算法和 開方地址法

由於 ThreadLocal 在每個 Thread 裡面的唯一性和特殊性，為其定製了特殊的 hashCode 生成方式，能夠很好的散列在 table 中，有效的減少hash衝突。
基於較少的hash衝突，於是採用了開放地址法，開放地址法在沒有hash衝突的時候很好理解，在發生衝突時的代碼就有些繞。因此理解 ThreadLocalMap 的新增、刪除、查找、清除等操作，需要對開方地址法的hash衝突處理有較清晰的思路，最好在手邊畫一畫開放地址法的hash衝突情況，目前沒有在網上找的很好的講解，爭取在後續文章補充。

ThreadLocal存儲到ThreadLocalMap的過程

結論:

​ 在ThreadLoalMap中，也是初始化一個大小16的Entry數組，Entry對象用來保存每一個key-value鍵值對，只不過這裡的key永遠都是ThreadLocal對象，是不是很神奇，通過ThreadLocal對象的set方法，結果把ThreadLocal對象自己當做key，放進了ThreadLoalMap中。

ThreadLocal類的get方法

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();
}

ThreadLocal類的set方法:

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

ThreadLocal類的setInitialValue方法:

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

• 假如ThreadLocal類的get方法獲取不到map,則執行ThreadLocal類的setInitialValue方法,如果ThreadLocal類的setInitialValue獲取不到map,則執行ThreadLocal類的createMap方法,獲取到執行ThreadLocalMap的set方法
• 假如ThreadLocal類的set方法獲取不到map,則執行ThreadLocal類的createMap方法,獲取到執行ThreadLocalMap的set方法

綜上兩點則可以得到,如果得到map則會執行下麵的set方法

ThreadLocalMap的set方法

private Entry[] table;

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;
  // 用key的hashCode計算槽位
  int i = key.threadLocalHashCode & (len-1);
    // hash衝突時，使用開放地址法
  // 因為獨特和hash演算法，導致hash衝突很少，一般不會走進這個for迴圈
  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，說明 key 已經被回收了，進入替換方法
    if (k == null) {
      replaceStaleEntry(key, value, i);
      return;
    }
  }
    // 新增 Entry
  tab[i] = new Entry(key, value);
  int sz = ++size;
  // 清除一些過期的值，並判斷是否需要擴容
  if (!cleanSomeSlots(i, sz) && sz >= threshold)
    // 擴容
    rehash();
}

得不到map,則會執行ThreadLocal類的createMap方法:

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

最後執行的還是ThreadLocalMap的構造方法:

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);
}

所以,無論是否存在ThreadLocalMap,都是會走從ThreadLocalMap的set方法或者ThreadLocalMap的構造方法,從ThreadLocalMap的set方法和構造方法可以看出:

以TreadLocal為key,傳入的參數為value組成的entry最終是存在於ThreadLocalMap中的Entry[]數組中的,

而組成的entry在數組的下標則為ThreadLocal類中的final變數threadLocalHashCode(threadLocalHashCode是通過CAS實現增長的,所以不會是重覆的值)與Entry[]數組長度&運算(與運算)得到,下標對應的值就是組成的entry

當獲取存儲在ThreadLocalMap中Entry[]數組的entry的時候

private Entry getEntry(ThreadLocal<?> key) {
  //private 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);
}

先通過ThreadLocal類中的final變數threadLocalHashCode與Entry[]數組長度&運算(與運算)得到下標,然後根據下標從Entry[]數組中取出entry,然後再進一步進行運算.

所以由此得出結論:

一個線程有多個ThreadLocal對象,將各個ThreadLocal存儲到ThreadLocalMap的時候,實際上是將各個ThreadLocal存儲到了內部類ThreadLocalMap的Entry[]數組中,在數組中的下標依賴各個ThreadLocal中的final變數threadLocalHashCode.

此下的結論待證明和改正:

由此得出ThreadLocalMap使用ThreadLocal的弱引用作為key，因為如果一個ThreadLocal沒有外部強引用引用他，那麼系統gc的時候，這個ThreadLocal勢必會被回收，這樣一來，就無法通過該ThreadLocal的threadLocalHashCode計算出下標以訪問存儲在ThreadLocalMap中entry，所以此時,ThreadLocalMap中此下標的entry就沒辦法被訪問,且沒辦法倍刪除,時間長了則會產生記憶體溢出.(ThreadLocalMap中就會出現key為null的Entry，就沒有辦法訪問這些key為null的Entry的value(原文的解釋,前面的是自己的理解,還要參考一下進一步確認https://www.jianshu.com/p/56f64e3c1b6c))

ThreadLocal的記憶體泄露問題

根據上面Entry方法的源碼，我們知道ThreadLocalMap是使用ThreadLocal的弱引用作為Key的。下圖是本文介紹到的一些對象之間的引用關係圖，實線表示強引用，虛線表示弱引用：

如上圖，ThreadLocalMap使用ThreadLocal的弱引用作為key，如果一個ThreadLocal沒有外部強引用引用他，那麼系統gc的時候，這個ThreadLocal勢必會被回收，這樣一來，ThreadLocalMap中就會出現key為null的Entry，就沒有辦法訪問這些key為null的Entry的value，

如果當前線程再遲遲不結束的話，這些key為null的Entry的value就會一直存在一條強引用鏈：
Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value
永遠無法回收，造成記憶體泄露。
　　
ThreadLocalMap設計時的對上面問題的對策：
ThreadLocalMap的getEntry函數的流程大概為：

1. 首先從ThreadLocal的直接索引位置(通過ThreadLocal.threadLocalHashCode & (table.length-1)運算得到)獲取Entry e，如果e不為null並且key相同則返回e；
2. 如果e為null或者key不一致則向下一個位置查詢，如果下一個位置的key和當前需要查詢的key相等，則返回對應的Entry。否則，如果key值為null，則擦除該位置的Entry，並繼續向下一個位置查詢。在這個過程中遇到的key為null的Entry都會被擦除，那麼Entry內的value也就沒有強引用鏈，自然會被回收。仔細研究代碼可以發現，set操作也有類似的思想，將key為null的這些Entry都刪除，防止記憶體泄露。

但是光這樣還是不夠的，上面的設計思路依賴一個前提條件：要調用ThreadLocalMap的getEntry函數或者set函數,這當然是不可能任何情況都成立的.

所以解決方法:

• 需要使用者手動調用ThreadLocal的remove函數，手動刪除不再需要的ThreadLocal，防止記憶體泄露。
• 所以JDK建議將ThreadLocal變數定義成private static的，這樣的話ThreadLocal的生命周期就更長，由於一直存在ThreadLocal的強引用，所以ThreadLocal也就不會被回收，也就能保證任何時候都能根據ThreadLocal的弱引用訪問到Entry的value值，然後remove它，防止記憶體泄露。

ThreadLocal的應用場景

最常見的ThreadLocal使用場景為 用來解決資料庫連接、Session管理等。如：

​ 資料庫連接：

private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {  
    public Connection initialValue() {  
        return DriverManager.getConnection(DB_URL);  
    }  
};  
  
public static Connection getConnection() {  
    return connectionHolder.get();  
}  

Session管理：

private static final ThreadLocal threadSession = new ThreadLocal();  
  
public static Session getSession() throws InfrastructureException {  
    Session s = (Session) threadSession.get();  
    try {  
        if (s == null) {  
            s = getSessionFactory().openSession();  
            threadSession.set(s);  
        }  
    } catch (HibernateException ex) {  
        throw new InfrastructureException(ex);  
    }  
    return s;  
}  

當時做記錄的時候忘記記錄原文鏈接了,作者看到之後可以私信我,我補上原文鏈接.