前言

ThreadLocal ，像是一個神祕的黑衣人，令人望而生畏。唯有下定決心，一探究竟，方能解開他神祕的面紗、在Android中，Handler，EventBus，ConnectionPool 等等，都曾出現它的身影

是什麼東西？

看到Thread，就想到應該是與執行緒有關吧，其次，Local是說本地，那組合起來就是執行緒私有，就是說每個執行緒都有備份，各備份不是同一個物件，一般來說，他的用途就是讓各個執行緒擁有不用的物件，它的物件都是 new 出來的，哪有人可能會問，既然是 new 出來的，那為什麼還要用 ThreadLocal，直接 new 一個物件不就行了，你如果不仔細瞭解 ThreadLocal，就很難解答這樣的問題

前世今生

是一個泛型類

public class ThreadLocal<T> {}

原始碼解析

屬性

nextHashCode 是獲取 hashcode 值，HASH_INCREMENT 初始值為0x61c88647，nextHashCode()函式每次呼叫增加增量獲取下一個值，大家可以好好看看Atomic的實現，以及底層Unsafe的語義

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

函式

初始值函式

    protected T initialValue() {
        return null;
    }

set ，將值拷貝到當前執行緒，使用ThreadLocalMap，這是一個內部類，要了解ThreadLocal，這個類是不得不瞭解的

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

    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

一探ThreadLocalMap，前方高能，他是一個靜態內部類，類似於WeakHashMap，只不過他沒有WeakHashMap那麼強大，沒有Map那麼多的介面，不過作為一個內部類，只需要為ThreadLocal服務就可以了，這一條可以在EffectiveJava裡找到，廢話不多說，看一下他的Entry，繼承自WeakReference，關於WeakReference，又可以花大篇幅來介紹了，不過現在暫時不說了，你只要記住當發生GC的時候，WeakReference的物件都會被回收。同樣內部也是用Entry陣列，預設大小為16，set 函式需要注意的是如何處理雜湊碰撞的問題，這裡扯一下，處理雜湊碰撞的如HashMap使用了拉鍊法，而這裡使用了簡單的開發地址法，具體來說就是如果發生了碰撞，就位置就+1，一直到有位置。

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;
            }
        /**
         * The initial capacity -- MUST be a power of two.
         */
        private static final int INITIAL_CAPACITY = 16;

        /**
         * The table, resized as necessary.
         * table.length MUST always be a power of two.
         */
        private Entry[] table;

        /**
         * The number of entries in the table.
         */
        private int size = 0;

        /**
         * The next size value at which to resize.
         */
        private int threshold; // Default to 0
        }
        // set 函式，同樣也是使用key的hashcode 與 len-1的
        // 與值
        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)]) {
                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;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

最重要的 get 函式，我們需要記住的是，每個執行緒有一個ThreadLocalMap，每個Map可以放很多個值，也就是不用的ThreadLocal物件。如果Get 不到資料的話，就會呼叫InitialValue函式進行賦值，所以有時候我們會重寫這個函式，以保證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.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

由於使用了WeakReference，可能會存在值丟失，那ThreadLocalMap又是怎麼處理這種情況呢？首先自然是處理hash碰撞的問題，通過nextIndex來遍歷，其中如果出現某個key獲取不到的話，就會執行
expungeStaleEntry(i) 刪除舊的entry，具體的做法就是刪除這個entry，以及之後出現為空的所有entry

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 int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

            // expunge entry at staleSlot
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;

            // 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();
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                    if (h != i) {
                        tab[i] = null;

                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

小結

一個 ThreadLocal 竟包含了如此多的知識，當你熟讀各種原始碼的時候，各種設計模式，各種細節，作者實現的非常有借鑑意義，理解了這樣的原始碼，在今後的專案中使用類似的，便可以知其然知其所以然，做到各種框架的深度定製，甚至實現自己的框架！

歡迎討論～