[[397941]]

本文轉載自微信公眾號「安琪拉的博客」，作者安琪拉的博客。轉載本文請聯系安琪拉的博客公眾號。

開場

杭州某商務樓里，正發生著一起求職者和面試官的battle。

面試官：你先自我介紹一下。

安琪拉：面試官你好，我是草叢三婊，最強中單(妲己不服)，草地摩托車車手，第21套廣播體操推廣者，火的傳人安琪拉，這是我的簡歷，請過目。

面試官：看你簡歷上寫熟悉多線程編程，熟悉到什么程度?

安琪拉：精通。

對。。。，你沒看錯，問就是“精通”，把666打在評論區。

面試官：

[心想] 莫不是個憨批，上來就說自己精通，誰把精通掛嘴上，莫不是個愣頭青嘞!

面試官：那我們開始吧。用過Threadlocal 吧?

安琪拉：用過。

面試官：那你跟我講講 ThreadLocal 在你們項目中的用法吧。

安琪拉：我們項目屬于保密項目，無可奉告，你還是換個問題吧!

面試官：那說個不保密的項目，或者你直接告訴我Threadlocal 的實現原理吧。 

正題

安琪拉：show time。。。

安琪拉：舉個栗子，我們支付寶每秒鐘同時會有很多用戶請求，那每個請求都帶有用戶信息，我們知道通常都是一個線程處理一個用戶請求，我們可以把用戶信息丟到Threadlocal里面，讓每個線程處理自己的用戶信息，線程之間互不干擾。

面試官：等等，問你個私人問題，為什么從支付寶跑出來面試，受不了PUA了嗎?

安琪拉：PUA我，不存在的，能PUA我的人還沒出生呢!公司食堂吃膩了，想換換口味。

面試官：那你來給我講講Threadlocal是干什么的?

安琪拉：Threadlocal 主要用來做線程變量的隔離，這么說可能不是很直觀。

還是說前面提到的例子，我們程序在處理用戶請求的時候，通常后端服務器是有一個線程池，來一個請求就交給一個線程來處理，那為了防止多線程并發處理請求的時候發生串數據，比如AB線程分別處理安琪拉和妲己的請求，A線程本來處理安琪拉的請求，結果訪問到妲己的數據上了，把妲己支付寶的錢轉走了。

所以就可以把安琪拉的數據跟A線程綁定，線程處理完之后解除綁定。

面試官：那把你剛才說的場景用偽代碼實現一下，來筆給你!

安琪拉：ok

//存放用戶信息的ThreadLocal 
private static final ThreadLocal<UserInfo> userInfoThreadLocal = new ThreadLocal<>(); 
 
public Response handleRequest(UserInfo userInfo) { 
  Response response = new Response(); 
  try { 
    // 1.用戶信息set到線程局部變量中 
    userInfoThreadLocal.set(userInfo); 
    doHandle(); 
  } finally { 
    // 3.使用完移除掉 
    userInfoThreadLocal.remove(); 
  } 
 
  return response; 
} 
     
//業務邏輯處理 
private void doHandle () { 
  // 2.實際用的時候取出來 
  UserInfo userInfo = userInfoThreadLocal.get(); 
  //查詢用戶資產 
  queryUserAsset(userInfo); 
} 

1.2.3 步驟很清楚了。

面試官：那你跟我說說Threadlocal 怎么實現線程變量的隔離的?

安琪拉：Oh, 這么快進入正題，我先給你畫個圖，如下：

面試官：圖我看了，那你對著前面你寫的代碼講一下對應圖中流程。

安琪拉：沒問題

• 首先我們通過ThreadLocal userInfoThreadLocal = new ThreadLocal() 初始化了一個Threadlocal 對象，就是上圖中說的Threadlocal 引用，這個引用指向堆中的ThreadLocal 對象;
• 然后我們調用userInfoThreadLocal.set(userInfo); 這里做了什么事呢?

我們把源代碼拿出來，看一看就清晰了。

我們知道 Thread 類有個 ThreadLocalMap 成員變量，這個Map key是Threadlocal 對象，value是你要存放的線程局部變量。

# Threadlocal類 Threadlocal.class  
public void set(T value) { 
  //獲取當前線程Thread，就是上圖畫的Thread 引用 
  Thread t = Thread.currentThread();  
  //Thread類有個成員變量ThreadlocalMap，拿到這個Map 
  ThreadLocalMap map = getMap(t); 
  if (map != null) 
    //this指的就是Threadlocal對象 
    map.set(this, value); 
  else 
    createMap(t, value); 
} 
 
ThreadLocalMap getMap(Thread t) { 
  //獲取線程的ThreadLocalMap 
  return t.threadLocals; 
} 
 
void createMap(Thread t, T firstValue) { 
  //初始化 
  t.threadLocals = new ThreadLocalMap(this, firstValue); 
} 

# Thread類 Thread.class 
public class Thread implements Runnable { 
    //每個線程都有自己的ThreadLocalMap 成員變量 
    ThreadLocal.ThreadLocalMap threadLocals = null; 
} 

這里是在當前線程對象的ThreadlocalMap中put了一個元素(Entry)，key是Threadlocal對象，value是userInfo。

理解兩件事就都清楚了：

ThreadLocalMap 類的定義在 Threadlocal中。

• 第一，Thread 對象是Java語言中線程運行的載體，每個線程都有對應的Thread 對象，存放線程相關的一些信息，
• 第二，Thread類中有個成員變量ThreadlocalMap，你就把他當成普通的Map，key存放的是Threadlocal對象，value是你要跟線程綁定的值(線程隔離的變量)，比如這里是用戶信息對象(UserInfo)。

面試官：你剛才說Thread 類有個 ThreadlocalMap 屬性的成員變量，但是ThreadlocalMap 的定義卻在Threadlocal 中，為什么這么做?

安琪拉：我們看下ThreadlocalMap的說明

class 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. 

大概意思是ThreadLocalMap 就是為維護線程本地變量而設計的，只做這一件事情。

這個也是為什么 ThreadLocalMap 是Thread的成員變量，但是卻是Threadlocal 的內部類(非public，只有包訪問權限，Thread和Threadlocal都在java.lang 包下)，就是讓使用者知道ThreadLocalMap就只做保存線程局部變量這一件事的。

面試官：既然是線程局部變量，那為什么不用線程對象(Thread對象)作為key，這樣不是更清晰，直接用線程作為key獲取線程變量?

安琪拉：這樣設計會有個問題，比如: 我已經把用戶信息存在線程變量里了，這個時候需要新增加一個線程變量，比方說新增用戶地理位置信息，我們ThreadlocalMap 的key用的是線程，再存一個地理位置信息，key都是同一個線程(key一樣)，不就把原來的用戶信息覆蓋了嘛。Map.put(key,value) 操作熟悉吧，所以網上有些文章說ThreadlocalMap使用線程作為key是瞎扯的。

面試官：那新增地理位置信息應該怎么做?

安琪拉：新創建一個Threadlocal對象就好了，因為ThreadLocalMap的key是Threadlocal 對象，比如新增地理位置，我就再 Threadlocal < Geo> geo = new Threadlocal(), 存放地理位置信息，這樣線程的ThreadlocalMap里面會有二個元素，一個是用戶信息，一個是地理位置。

面試官：ThreadlocalMap 是什么數據結構實現的?

安琪拉：跟HashMap 一樣，也是數組實現的。

代碼如下：

class ThreadLocalMap { 
 //初始容量 
 private static final int INITIAL_CAPACITY = 16; 
 //存放元素的數組 
 private Entry[] table; 
 //元素個數 
 private int size = 0; 
} 

table 就是存儲線程局部變量的數組，數組元素是Entry類，Entry由key和value組成，key是Threadlocal對象，value是存放的對應線程變量

我們前面舉得例子，數組存儲結構如下圖：

面試官：ThreadlocalMap 發生hash沖突怎么辦?跟HashMap 有什么區別?

安琪拉：【心想】第一次碰到有問ThreadlocalMap哈希沖突的，這個面試越來越有意思了。

說道：有區別的，對待哈希沖突，HashMap采用的鏈表 + 紅黑樹的形式，如下圖，鏈表長度過長(>8) 就會轉成紅黑樹:

ThreadlocalMap既沒有鏈表，也沒有紅黑樹，采用的是鏈地址法， 鏈地址法就是如果發生沖突，ThreadlocalMap直接往后找相鄰的下一個節點，如果相鄰節點為空，直接存進去，如果不為空，繼續往后找，直到找到空的，把元素放進去，或者元素個數超過數組長度閾值，進行擴容。

如下圖：還是以之前的例子講解，ThreadlocalMap 數組長度是4，現在存地理位置的時候發生hash沖突(位置1已經有數據)，那就把往后找，發現2 這個位置為空，就直接存放在2這個位置。

源代碼(如果閱讀起來困難，可以看完后文回過頭來閱讀):

private void set(ThreadLocal<?> key, Object value) { 
  Entry[] tab = table; 
  int len = tab.length; 
  // hashcode & 操作其實就是 %數組長度取余數，例如：數組長度是4，hashCode % (4-1) 就找到要存放元素的數組下標 
  int i = key.threadLocalHashCode & (len-1); 
 
  //找到數組的空槽（=null），一般ThreadlocalMap存放元素不會很多 
  for (Entry e = tab[i]; 
       e != null; //找到數組的空槽（=null） 
       e = tab[i = nextIndex(i, len)]) { 
    ThreadLocal<?> k = e.get(); 
 
    //如果key值一樣，算是更新操作，直接替換 
    if (k == key) { 
      e.value = value; 
      return; 
    } 
  //key為空，做替換清理動作，這個后面聊WeakReference的時候講 
    if (k == null) { 
      replaceStaleEntry(key, value, i); 
      return; 
    } 
  } 
 //新new一個Entry 
  tab[i] = new Entry(key, value); 
  //數組元素個數+1 
  int sz = ++size; 
  //如果沒清理掉元素或者存放元素個數超過數組閾值，進行擴容 
  if (!cleanSomeSlots(i, sz) && sz >= threshold) 
    rehash(); 
} 
 
//順序遍歷 +1 到了數組尾部，又回到數組頭部（0這個位置） 
private static int nextIndex(int i, int len) { 
  return ((i + 1 < len) ? i + 1 : 0); 
} 
 
// get()方法，根據ThreadLocal key獲取線程變量 
private Entry getEntry(ThreadLocal<?> key) { 
  //計算hash值 & 操作其實就是 %數組長度取余數，例如：數組長度是4，hashCode % (4-1) 就找到要查詢的數組地址 
  int i = key.threadLocalHashCode & (table.length - 1); 
  Entry e = table[i]; 
  //快速判斷 如果這個位置有值，key相等表示找到了，直接返回 
  if (e != null && e.get() == key) 
    return e; 
  else 
    return getEntryAfterMiss(key, i, e); //miss之后順序往后找（鏈地址法，這個后面再介紹） 
} 

面試官：我看你最前面圖中畫的ThreadlocalMap 中key是 WeakReference類型，能講講Java中有幾種類似的引用，什么區別嗎?

安琪拉：可以

• 強引用是使用最普遍的引用。如果一個對象具有強引用，那垃圾回收器絕不會回收它，當內存空間不足時，Java虛擬機寧愿拋出OutOfMemoryError錯誤，使程序異常終止，也不會靠隨意回收具有強引用的對象來解決內存不足的問題。
• 如果一個對象只具有軟引用，則內存空間充足時，垃圾回收器就不會回收它;如果內存空間不足了，就會回收這些對象的內存。
• 弱引用與軟引用的區別在于：只具有弱引用的對象擁有更短暫的生命周期。在垃圾回收器線程掃描內存區域時，一旦發現了只具有弱引用的對象，不管當前內存空間足夠與否，都會回收它的內存。不過，由于垃圾回收器是一個優先級很低的線程，因此不一定會很快發現那些只具有弱引用的對象。
• 虛引用顧名思義，就是形同虛設。與其他幾種引用都不同，虛引用并不會決定對象的生命周期。如果一個對象僅持有虛引用，那么它就和沒有任何引用一樣，在任何時候都可能被垃圾回收器回收。

妥妥的八股文啊!尷尬(─.─|||。

面試官：那你能講講為什么ThreadlocalMap 中key 設計成 WeakReference(弱引用)類型嗎?

安琪拉：可以的，為了盡最大努力避免內存泄漏。

面試官：能詳細講講嗎?為什么是盡最大努力，你前面也講被WeakReference 引用的對象會直接被GC(內存回收器) 回收，為什么不是直接避免了內存泄漏呢?

安琪拉：我們還是看下下面這張圖：

private static final ThreadLocal<UserInfo> userInfoThreadLocal = new ThreadLocal<>(); 
userInfoThreadLocal.set(userInfo); 

這里的引用關系是userInfoThreadLocal 引用了ThreadLocal對象，這是個強引用，ThreadLocal對象同時也被ThreadlocalMap的key引用，這是個WeakReference引用，我們前面說GC要回收ThreadLocal對象的前提是它只被WeakReference引用，沒有任何強引用。

為了方便大家理解弱引用，我寫了段Demo程序

public static void main(String[] args) { 
  Object angela = new Object(); 
  //弱引用 
  WeakReference<Object> weakReference = new WeakReference<>(angela); 
  //angela和弱引用指向同一個對象 
  System.out.println(angela);//java.lang.Object@4550017c 
  System.out.println(weakReference.get());//java.lang.Object@4550017c  
  //將強引用angela置為null，這個對象就只剩下弱引用了,內存夠用，弱引用也會被回收 
  angela = null;  
  System.gc();//內存夠用不會自動gc，手動喚醒gc 
  System.out.println(angela);//null 
  System.out.println(weakReference.get());//null 
} 

可以看到一旦一個對象只被弱引用引用，GC的時候就會回收這個對象。

所以只要ThreadLocal對象如果還被 userInfoThreadLocal(強引用) 引用著，GC是不會回收被WeakReference引用的對象的。

面試官：那既然ThreadLocal對象有強引用，回收不掉，干嘛還要設計成WeakReference類型呢?

安琪拉：ThreadLocal的設計者考慮到線程往往生命周期很長，比如經常會用到線程池，線程一直存活著，根據JVM 根搜索算法，一直存在 Thread -> ThreadLocalMap -> Entry(元素)這樣一條引用鏈路, 如下圖，如果key不設計成WeakReference類型，是強引用的話，就一直不會被GC回收，key就一直不會是null，不為null Entry元素就不會被清理(ThreadLocalMap是根據key是否為null來判斷是否清理Entry)

所以ThreadLocal的設計者認為只要ThreadLocal 所在的作用域結束了工作被清理了，GC回收的時候就會把key引用對象回收，key置為null，ThreadLocal會盡力保證Entry清理掉來最大可能避免內存泄漏。

來看下代碼：

//元素類 
static class Entry extends WeakReference<ThreadLocal<?>> { 
  /** The value associated with this ThreadLocal. */ 
  Object value; //key是從父類繼承的，所以這里只有value 
 
  Entry(ThreadLocal<?> k, Object v) { 
    super(k); 
    value = v; 
  } 
} 
 
//WeakReference 繼承了Reference，key是繼承了范型的referent 
public abstract class Reference<T> { 
  //這個就是被繼承的key 
  private T referent;  
  Reference(T referent) { 
    this(referent, null); 
  } 
} 

Entry 繼承了WeakReference類，Entry 中的 key 是WeakReference類型的，在Java 中當對象只被 WeakReference 引用，沒有其他對象引用時，被WeakReference 引用的對象發生GC 時會直接被回收掉。

面試官：那如果Threadlocal 對象一直有強引用，那怎么辦?豈不是有內存泄漏風險。

安琪拉：最佳實踐是用完手動調用remove函數。

我們看下源碼：

class Threadlocal { 
  public void remove() { 
      //這個是拿到線程的ThreadLocalMap 
      ThreadLocalMap m = getMap(Thread.currentThread()); 
      if (m != null) 
        m.remove(this); //this就是ThreadLocal對象，移除，方法在下面 
  } 
} 
 
class ThreadlocalMap { 
  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; 
      } 
   } 
 } 
} 
 
//這個方法就是做元素清理 
private int expungeStaleEntry(int staleSlot) { 
  Entry[] tab = table; 
  int len = tab.length; 
 
  //把staleSlot的value置為空，然后數組元素置為空 
  tab[staleSlot].value = null; 
  tab[staleSlot] = null; 
  size--; //元素個數-1 
 
  // Rehash until we encounter null 
  Entry e; 
  int i; 
  for (i = nextIndex(staleSlot, len); 
       (e = tab[i]) != null; 
       i = nextIndex(i, len)) { 
    ThreadLocal<?> k = e.get(); 
    //k 為null代表引用對象被GC回收掉了 
    if (k == null) { 
      e.value = null; 
      tab[i] = null; 
      size--; 
    } else { 
      //因為元素個數減少了，就把后面的元素重新hash 
      int h = k.threadLocalHashCode & (len - 1); 
      //hash地址不相等，就代表這個元素之前發生過hash沖突(本來應該放在這沒放在這)， 
      //現在因為有元素被移除了，很有可能原來沖突的位置空出來了，重試一次 
      if (h != i) { 
        tab[i] = null; 
 
        //繼續采用鏈地址法存放元素 
        while (tab[h] != null) 
          h = nextIndex(h, len); 
        tab[h] = e; 
      } 
    } 
  } 
  return i; 
} 

面試官：你有沒有用Threadlocal的工程實際經歷，給我講講。

安琪拉：有啊!

之前我跟你們一面面試官聊過，我是怎么把支付寶后臺負責的系統四十幾個核心rpc接口性能大幅度提升的，下面這個就是其中一個接口切流之后的效果，其中就用到了Threadlocal。圖片

面試官：嗯，說說。

安琪拉：我剛才說有四十多個接口要做技改優化，那風險是很高的，我需要保證接口切換后業務不受影響，也叫等效切換。

流程是這樣的：

• 把這四十多個接口按照業務含義定義了接口常量名稱，比如接口名alipay.quickquick.follow.angela;
• 按照接口的流量從低到高開始切流，提前配置中心配置好每個接口的切流比例和用戶白名單;
• 切流也有講究，先按照userId白名單切，再按照userId尾號切百分比，完全沒問題再完整切;
• 在頂層抽象模版方法的入口通過ThreadLocal Set 接口名，把接口名塞進去;

然后我在切流的地方通過ThreadLocal 獲取接口名，用于接口切流判斷切流;

面試官：最后一個問題，如果我有很多變量都要塞到ThreadlocalMap中，那豈不是要申明很多個Threadlocal 對象?有沒有好的解決辦法。

安琪拉：我們的最佳實踐是搞個再封裝一下，把ThreadLocalMap 的value 弄成Map就好了，這樣只要一個Threadlocal 對象就好了。

面試官：能詳細講講嗎?

安琪拉：講不動了，太累了。

面試官：講講。

安琪拉：真不想講了。

面試官：那今天先到這，您出了這個門右拐，回去等通知吧!