ThreadLocal原始碼分析（JDK8）
阿新 • • 發佈：2019-01-01
ThreadLocal特性及使用場景：
1、方便同一個執行緒使用某一物件，避免不必要的引數傳遞；
2、執行緒間資料隔離（每個執行緒在自己執行緒裡使用自己的區域性變數，各執行緒間的ThreadLocal物件互不影響）；
3、獲取資料庫連線、Session、關聯ID（比如日誌的uniqueID，方便串起多個日誌）；
ThreadLocal應注意：
1、ThreadLocal並未解決多執行緒訪問共享物件的問題；
2、ThreadLocal並不是每個執行緒拷貝一個物件，而是直接new（新建）一個；
3、如果ThreadLocal.set()的物件是多執行緒共享的，那麼還是涉及併發問題。
1、ThreadLocal<T>初始化 
5、ThreadLocal-ThreadLocalMap原始碼分析
5.1、Entry getEntry(ThreadLocal<?> key)
首先來看get方法，你會發現ThreadLocalMap的get方法和傳統Map不同，其返回的不是key-value的value，而是整個entry，當時entry的key是ThreadLocal，value是存放的值，這點是一致的。
a、getEntry原始碼分析：
rehash()： size：table的實際entry數量；擴容閾值threshold：table.lenrth（預設16）大小的2/3； 首先呼叫expungeStaleEntries刪除所有過期資料，如果清理資料後size>=threshold的3/4，則2倍擴容。 ps：閾yù值又叫臨界值，是指一個效應能夠產生的最低值或最高值。閥fá 控制、開關、把持。 ThreadLocalMap和HashMap在hash衝突時的解決方案對比： HashMap：若衝突則將新資料按連結串列或紅黑樹邏輯插入。 put(K key, V value)的邏輯： 1、判斷鍵值對陣列tab[]是否為空或為null，是則resize()； 2、根據鍵值key的hashCode()計算hash值得到當前Node的索引i（bucketIndex），如果tab[i]==null【沒碰撞】，直接新建節點新增，否則【碰撞】轉入3 3、判斷當前陣列中處理hash衝突的方式為紅黑樹還是連結串列(check第一個節點型別即可),分別處理。【①是紅黑樹則按紅黑樹邏輯插入；②是連結串列，則遍歷連結串列，看是否有key相同的節點；③有則更新value值，沒有則新建節點，此時若連結串列數量大於閥值8【9個】，則呼叫treeifyBin方法（此方法先判斷table是否為null或tab.length小於64，是則執行resize操作，否則才將連結串列改為紅黑樹）。】 4、如果size+1> threshold則resize。 ThreadLocalMap： 1、若指定位置index已有資料entry，逐個遍歷entry： 1.1、若index處key相同，則更新value； 1.2、若index處key為null，則呼叫replaceStaleEntry清理過期資料並插入新資料（從index處挨個遍歷，直到找到相同key更新value結束，或者一直未找到，則在index處放入new Entry）。replaceStaleEntry遍歷時會將entry逐個後移，也就是說set進去的最新entry一定會放在index處，方便get時直接命中。 2、index處無資料，則放入新entry；隨後清理過期資料並判斷是否2倍擴容（size>=threshold的3/4）。 參考資料： http://www.cnblogs.com/dolphin0520/p/3920407.html 有任何問題，歡迎指正探討。
ThreadLocal類變數有3個，其中2個是靜態變數（包括一個常量），實際作為作為ThreadLocal例項的變數只有threadLocalHashCode這1個，而且已經初始化就不可變了。 建立ThreadLocal例項時有哪些操作呢： ThreadLocal初始化時會呼叫nextHashCode()方法初始化threadLocalHashCode，且threadLocalHashCode初始化後不可變。threadLocalHashCode可用來標記不同的ThreadLocal例項。 2、內部類 2.1 ThreadLocalMap ThreadLocalMap是定製的hashMap，僅用於維護當前執行緒的本地變數值。僅ThreadLocal類對其有操作許可權，是Thread的私有屬性。為避免佔用空間較大或生命週期較長的資料常駐於記憶體引發一系列問題，hash table的key是弱引用WeakReferences。當空間不足時，會清理未被引用的entry。 ThreadLocalMap中的重點：private static AtomicInteger nextHashCode = new AtomicInteger(); private static intnextHashCode() { return nextHashCode.getAndAdd(HASH_INCREMENT); }
Note： ThreadLocalMap的key是ThreadLocal，value是Object（即我們所謂的“執行緒本地資料”）。 2.2 SuppliedThreadLocal<T> extends ThreadLocal<T> SuppliedThreadLocal是JDK8新增的內部類，只是擴充套件了ThreadLocal的初始化值的方法而已，允許使用JDK8新增的Lambda表示式賦值。需要注意的是，函式式介面Supplier不允許為null。 原始碼如下：static class Entryextends WeakReference<ThreadLocal<?>>{ /** The value associated with this ThreadLocal. */ Object value; Entry(ThreadLocal<?> k, Object v){ super(k); value= v; } }
static final class SuppliedThreadLocal<T>extends ThreadLocal<T>{
private final Supplier<?extends T> supplier;
SuppliedThreadLocal(Supplier<?extends T> supplier){
this.supplier= Objects.requireNonNull(supplier);
}
@Override
protected T initialValue(){
return supplier.get();
}
}public T get(){
Thread t= Thread.currentThread(); // 獲取當前執行緒
ThreadLocalMap map= getMap(t); // 獲取當前執行緒對應的Map
if(map!=null){
ThreadLocalMap.Entry e = map.getEntry(this); // 詳見3.1.1
if(e!=null){ // map不為空且當前執行緒有value，返回value
@SuppressWarnings("unchecked")
T result=(T)e.value;
return result;
}
}
return setInitialValue(); // 初始化再返回值
}ThreadLocalMap getMap(Thread t){
returnt.threadLocals;
}private T setInitialValue(){
T value= initialValue(); //呼叫重寫的initialValue，返回新值
Thread t= Thread.currentThread();
ThreadLocalMap map= getMap(t);
if(map!=null) // 當前執行緒的ThreadLocalMap不為空，則直接賦值
map.set(this, value);
else
// 為當前執行緒創造一個ThreadLocalMap(this, firstValue)並賦初值，this為當前執行緒
createMap(t, value);
return value;
}
protected T initialValue() {
return T; // 自定義返回值
};void createMap(Thread t, T firstValue){
t.threadLocals=new ThreadLocalMap(this, firstValue);
}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 void remove(){
ThreadLocalMap m= getMap(Thread.currentThread());
if(m!=null)
m.remove(this);
}public static<S> ThreadLocal<S> withInitial(Supplier<?extends S> supplier){
return new SuppliedThreadLocal<>(supplier);
}@Test
public void jdk8Test(){
Supplier<String> supplier =new Supplier<String>(){
@Override
public String get(){
return"supplier_new";
}
};
threadLocal= ThreadLocal.withInitial(supplier);
System.out.println(threadLocal.get());// supplier_new
threadLocal= ThreadLocal.withInitial(()->"sup_new_2");
System.out.println(threadLocal.get());// sup_new_2
ThreadLocal<DateFormat> localDate = ThreadLocal.withInitial(()->new SimpleDateFormat("yyyy-MM-dd"));
System.out.println(localDate.get().format(new Date()));// 2017-01-22
ThreadLocal<String> local =new ThreadLocal<>().withInitial(supplier);
System.out.println(local.get());// supplier_new
}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);
}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;
}private static int nextIndex(int i,int len){
return((i+1< len)? i+1:0); // 把索引加1即可
}private int expungeStaleEntry(int staleSlot){
Entry[] tab = table;
int len= tab.length;
// expunge entry at staleSlot
tab[staleSlot].value=null; // 擦除當前index處value
tab[staleSlot]=null; // 擦除當前index處key
size--;
// Rehash until we encounter null
Entry e;
int i;
for(i= nextIndex(staleSlot, len); // 計算下一個index
(e= tab[i])!=null; // 新index處entry不為空
i= nextIndex(i, len)){ // 計算下一個index
ThreadLocal<?> k = e.get(); // 獲取新key（ThreadLocal）
if(k==null){ // key為null，再次置空
e.value=null;
tab[i]=null;
size--;
}else{
int h= k.threadLocalHashCode&(len-1); // 計算新index
if(h!= i){ // index若未變化，說明沒有多餘的entry了
tab[i]=null;
// Unlike Knuth 6.4 Algorithm R, we must scan until
// null because multiple entries could have been stale.
// 一直掃到最後一個非空位置，將其值置為碰撞處第一個entry。
while(tab[h]!=null)
h= nextIndex(h, len);
tab[h]= e;
}
}
}
return i;
}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;
int i= key.threadLocalHashCode&(len-1);
for(Entry e= tab[i]; e !=null;e= tab[i= nextIndex(i, len)]){
// 當前index處已有entry
ThreadLocal<?> k = e.get();
if(k== key){ // key（ThreadLocal）相同，更新value
e.value= value;
return;
}
if(k==null){ // 出現過期資料
// 遍歷清洗過期資料並在index處插入新資料，其他資料後移
replaceStaleEntry(key, value, i);
return;
}
}
tab[i]=new Entry(key, value);
int sz=++size;
// 沒有過期資料被清理且實際size超過擴容閾值
if(!cleanSomeSlots(i, sz)&& sz>= threshold)
rehash();
}rehash()： size：table的實際entry數量；擴容閾值threshold：table.lenrth（預設16）大小的2/3； 首先呼叫expungeStaleEntries刪除所有過期資料，如果清理資料後size>=threshold的3/4，則2倍擴容。 ps：閾yù值又叫臨界值，是指一個效應能夠產生的最低值或最高值。閥fá 控制、開關、把持。 ThreadLocalMap和HashMap在hash衝突時的解決方案對比： HashMap：若衝突則將新資料按連結串列或紅黑樹邏輯插入。 put(K key, V value)的邏輯： 1、判斷鍵值對陣列tab[]是否為空或為null，是則resize()； 2、根據鍵值key的hashCode()計算hash值得到當前Node的索引i（bucketIndex），如果tab[i]==null【沒碰撞】，直接新建節點新增，否則【碰撞】轉入3 3、判斷當前陣列中處理hash衝突的方式為紅黑樹還是連結串列(check第一個節點型別即可),分別處理。【①是紅黑樹則按紅黑樹邏輯插入；②是連結串列，則遍歷連結串列，看是否有key相同的節點；③有則更新value值，沒有則新建節點，此時若連結串列數量大於閥值8【9個】，則呼叫treeifyBin方法（此方法先判斷table是否為null或tab.length小於64，是則執行resize操作，否則才將連結串列改為紅黑樹）。】 4、如果size+1> threshold則resize。 ThreadLocalMap： 1、若指定位置index已有資料entry，逐個遍歷entry： 1.1、若index處key相同，則更新value； 1.2、若index處key為null，則呼叫replaceStaleEntry清理過期資料並插入新資料（從index處挨個遍歷，直到找到相同key更新value結束，或者一直未找到，則在index處放入new Entry）。replaceStaleEntry遍歷時會將entry逐個後移，也就是說set進去的最新entry一定會放在index處，方便get時直接命中。 2、index處無資料，則放入新entry；隨後清理過期資料並判斷是否2倍擴容（size>=threshold的3/4）。 參考資料： http://www.cnblogs.com/dolphin0520/p/3920407.html 有任何問題，歡迎指正探討。
歡迎個人轉載，但須在文章頁面明顯位置給出原文連線；
未經作者同意必須保留此段宣告、不得隨意修改原文、不得用於商業用途，否則保留追究法律責任的權利。
【 CSDN 】：csdn.zxiaofan.com
【GitHub】：github.zxiaofan.com
如有任何問題，歡迎留言。祝君好運！
Life is all about choices！
將來的你一定會感激現在拼命的自己！