蔣麗苑ThreadLocal

ThreadLocal
threadlocal使用方法很簡單

static final ThreadLocal sThreadLocal = new ThreadLocal();
sThreadLocal.set()
sThreadLocal.get()

threadlocal而是一個執行緒內部的儲存類，可以在指定執行緒記憶體儲資料，資料儲存以後，只有指定執行緒可以得到儲存資料，官方解釋如下。

複製程式碼
/**

• This class provides thread-local variables. These variables differ from
• their normal counterparts in that each thread that accesses one (via its
• {@code get} or {@code set} method) has its own, independently initialized
• copy of the variable. {@code ThreadLocal} instances are typically private
• static fields in classes that wish to associate state with a thread (e.g.,
• a user ID or Transaction ID).
  */
  複製程式碼

大致意思就是ThreadLocal提供了執行緒記憶體儲變數的能力，這些變數不同之處在於每一個執行緒讀取的變數是對應的互相獨立的。通過get和set方法就可以得到當前執行緒對應的值。

做個不恰當的比喻，從表面上看ThreadLocal相當於維護了一個map，key就是當前的執行緒，value就是需要儲存的物件。

這裡的這個比喻是不恰當的，實際上是ThreadLocal的靜態內部類ThreadLocalMap為每個Thread都維護了一個陣列table，ThreadLocal確定了一個陣列下標，而這個下標就是value儲存的對應位置。。

作為一個儲存資料的類，關鍵點就在get和set方法。

複製程式碼
//set 方法
public void set(T value) {
//獲取當前執行緒
Thread t = Thread.currentThread();
//實際儲存的資料結構型別
ThreadLocalMap map = getMap(t);
//如果存在map就直接set，沒有則建立map並set
if (map != null)
map.set(this, value);
else
createMap(t, value);
}

//getMap方法
ThreadLocalMap getMap(Thread t) {
//thred中維護了一個ThreadLocalMap
return t.threadLocals;
}

//createMap
void createMap(Thread t, T firstValue) {
//例項化一個新的ThreadLocalMap，並賦值給執行緒的成員變數threadLocals
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
複製程式碼

從上面程式碼可以看出每個執行緒持有一個ThreadLocalMap物件。每一個新的執行緒Thread都會例項化一個ThreadLocalMap並賦值給成員變數threadLocals，使用時若已經存在threadLocals則直接使用已經存在的物件。

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

Thread中關於ThreadLocalMap部分的相關宣告，接下來看一下createMap方法中的例項化過程。

ThreadLocalMap
set方法
複製程式碼
//Entry為ThreadLocalMap靜態內部類，對ThreadLocal的若引用
//同時讓ThreadLocal和儲值形成key-value的關係
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;

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

}

//ThreadLocalMap構造方法
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
//內部成員陣列，INITIAL_CAPACITY值為16的常量
table = new Entry[INITIAL_CAPACITY];
//位運算，結果與取模相同，計算出需要存放的位置
//threadLocalHashCode比較有趣
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
複製程式碼

通過上面的程式碼不難看出在例項化ThreadLocalMap時建立了一個長度為16的Entry陣列。通過hashCode與length位運算確定出一個索引值i，這個i就是被儲存在table陣列中的位置。

前面講過每個執行緒Thread持有一個ThreadLocalMap型別的例項threadLocals，結合此處的構造方法可以理解成每個執行緒Thread都持有一個Entry型的陣列table，而一切的讀取過程都是通過操作這個陣列table完成的。

顯然table是set和get的焦點，在看具體的set和get方法前，先看下面這段程式碼。

//在某一執行緒宣告瞭ABC三種型別的ThreadLocal
ThreadLocal sThreadLocalA = new ThreadLocal();
ThreadLocal sThreadLocalB = new ThreadLocal();
ThreadLocal sThreadLocalC = new ThreadLocal();

由前面我們知道對於一個Thread來說只有持有一個ThreadLocalMap，所以ABC對應同一個ThreadLocalMap物件。為了管理ABC，於是將他們儲存在一個陣列的不同位置，而這個陣列就是上面提到的Entry型的陣列table。

那麼問題來了，ABC在table中的位置是如何確定的？為了能正常夠正常的訪問對應的值，肯定存在一種方法計算出確定的索引值i，show me code。

複製程式碼
//ThreadLocalMap中set方法。
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);

        //遍歷tab如果已經存在則更新值
        for (Entry e = tab[i];
             e != null;
             e = tab[i = nextIndex(i, len)]) {
            ThreadLocal<?> k = e.get();

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

            if (k == null) {
                replaceStaleEntry(key, value, i);
                return;
            }
        }
        
        //如果上面沒有遍歷成功則建立新值
        tab[i] = new Entry(key, value);
        int sz = ++size;
        //滿足條件陣列擴容x2
        if (!cleanSomeSlots(i, sz) && sz >= threshold)
            rehash();
    }

複製程式碼

在ThreadLocalMap中的set方法與構造方法能看到以下程式碼片段。

int i = key.threadLocalHashCode & (len-1)
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1)
簡而言之就是將threadLocalHashCode進行一個位運算（取模）得到索引i，threadLocalHashCode程式碼如下。
複製程式碼
//ThreadLocal中threadLocalHashCode相關程式碼.

private final int threadLocalHashCode = nextHashCode();

/**
 * The next hash code to be given out. Updated atomically. Starts at
 * zero.
 */
private static AtomicInteger nextHashCode =
    new AtomicInteger();

/**
 * The difference between successively generated hash codes - turns
 * implicit sequential thread-local IDs into near-optimally spread
 * multiplicative hash values for power-of-two-sized tables.
 */
private static final int HASH_INCREMENT = 0x61c88647;

/**
 * Returns the next hash code.
 */
private static int nextHashCode() {
    //自增
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

複製程式碼

因為static的原因，在每次new ThreadLocal時因為threadLocalHashCode的初始化，會使threadLocalHashCode值自增一次，增量為0x61c88647。

0x61c88647是斐波那契雜湊乘數,它的優點是通過它雜湊(hash)出來的結果分佈會比較均勻，可以很大程度上避免hash衝突，已初始容量16為例，hash並與15位運算計算陣列下標結果如下：

hashCode 陣列下標
0x61c88647 7
0xc3910c8e 14
0x255992d5 5
0x8722191c 12
0xe8ea9f63 3
0x4ab325aa 10
0xac7babf1 1
0xe443238 8
0x700cb87f 15
總結如下：

對於某一ThreadLocal來講，他的索引值i是確定的，在不同執行緒之間訪問時訪問的是不同的table陣列的同一位置即都為table[i]，只不過這個不同執行緒之間的table是獨立的。
對於同一執行緒的不同ThreadLocal來講，這些ThreadLocal例項共享一個table陣列，然後每個ThreadLocal例項在table中的索引i是不同的。
get()方法
複製程式碼
//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();
}

//ThreadLocalMap中getEntry方法
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);
}
複製程式碼

理解了set方法，get方法也就清楚明瞭，無非是通過計算出索引直接從陣列對應位置讀取即可。

ThreadLocal實現主要涉及Thread，ThreadLocal，ThreadLocalMap這三個類。關於ThreadLocal的實現流程正如上面寫的那樣，實際程式碼還有許多細節處理的部分並沒有在這裡寫出來。

ThreadLocal特性
ThreadLocal和Synchronized都是為了解決多執行緒中相同變數的訪問衝突問題，不同的點是

Synchronized是通過執行緒等待，犧牲時間來解決訪問衝突
ThreadLocal是通過每個執行緒單獨一份儲存空間，犧牲空間來解決衝突，並且相比於Synchronized，ThreadLocal具有執行緒隔離的效果，只有線上程內才能獲取到對應的值，執行緒外則不能訪問到想要的值。
正因為ThreadLocal的執行緒隔離特性，使他的應用場景相對來說更為特殊一些。在android中Looper、ActivityThread以及AMS中都用到了ThreadLocal。當某些資料是以執行緒為作用域並且不同執行緒具有不同的資料副本的時候，就可以考慮採用ThreadLocal。