一、背景

ThreadLocal類顧名思義就是，申明為ThreadLocal的變數，對於不同執行緒來說都是獨立的。

下面是一個例子：

public class Test {

    public static void main(String[] args) {
        ThreadLocalTest threadLocalTest = new ThreadLocalTest();

        for(int i = 0; i < 3; i++) {
            TaskTest taskTest = new TaskTest(threadLocalTest);
            Thread t = new
 
 Thread(taskTest);
            t.start();
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class TaskTest implements Runnable{
        ThreadLocalTest test;

        public
 
 TaskTest(ThreadLocalTest test) {
            this.test = test;
        }

        @Override
        public void run() {
            int tmp = test.localCnt.get();
            test.localCnt.set(tmp + 1);
            test.shareCnt += 1;
            System.out.println(Thread.currentThread().getName());
            System.out.println("LocalCnt:"
 
 + test.localCnt.get());
            System.out.println("SharedCnt:" + test.shareCnt);
        }
    }

    static class ThreadLocalTest
    {
        ThreadLocal<Integer> localCnt = new ThreadLocal<Integer>() {
            public Integer initialValue() {  
                return 0;  
            } 
        };

        int shareCnt = 0;

        public ThreadLocalTest() {

        }
    }
}

輸出結果:

Thread-0
LocalCnt:1
SharedCnt:1
Thread-1
LocalCnt:1
SharedCnt:2
Thread-2
LocalCnt:1
SharedCnt:3

基本原理：ThreadLocal會為每一個執行緒提供一個獨立的變數副本，從而隔離了多個執行緒對資料的訪問衝突。因為每一個執行緒都擁有自己的變數副本，從而也就沒有必要對該變數進行同步了。ThreadLocal提供了執行緒安全的共享物件，在編寫多執行緒程式碼時，可以把不安全的變數封裝進ThreadLocal。

二、儲存結構

在ThreadLocal類中定義了一個重要靜態內部類，ThreadLocalMap，用來儲存每個執行緒的區域性變數，程式碼如下

    static class ThreadLocalMap {

        // Entry繼承自WeakReference類，是儲存執行緒私有變數的資料結構
        // ThreadLocal例項作為引用，意味著如果ThreadLocal例項為null
        // 就可以從table中刪除對應的Entry。
        static class Entry extends WeakReference<ThreadLocal<?>> {

            Object value;

            // 把ThreadLocal與value封裝成Entry
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }

        // 陣列初始大小為16
        private static final int INITIAL_CAPACITY = 16;

        // 儲存陣列
        private Entry[] table;

        private int size = 0;
        private int threshold; // 預設為0
        private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }

        private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }

        private static int prevIndex(int i, int len) {
            return ((i - 1 >= 0) ? i - 1 : len - 1);
        }

        // 建構函式
        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);
        }

        private ThreadLocalMap(ThreadLocalMap parentMap) {
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            setThreshold(len);
            table = new Entry[len];

            for (int j = 0; j < len; j++) {
                Entry e = parentTable[j];
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
                    if (key != null) {
                        Object value = key.childValue(e.value);
                        Entry c = new Entry(key, value);
                        int h = key.threadLocalHashCode & (len - 1);
                        while (table[h] != null)
                            h = nextIndex(h, len);
                        table[h] = c;
                        size++;
                    }
                }
            }
        }

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

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

三、主要方法

public class ThreadLocal<T> {

    // 跟hash值相關的部分
    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);
    }

    // 此方法在每個執行緒中最多執行一次，如果第一次執行get()，會呼叫此方法
    // 如果在第一次執行get()之前已經呼叫過set()，則此方法永遠不執行
    // 可以看到預設返回null值，為了避免不必要錯誤，最好重寫此方法
    protected T initialValue() {
        return null;
    }

    // 建構函式
    public ThreadLocal() {
    }

    // 獲取執行緒所屬的值
    public T get() {

        // 獲取當前執行緒
        Thread t = Thread.currentThread();  

        // 每個執行緒有維護一個ThreadLocalMap變數，呼叫getMap獲取
        ThreadLocalMap map = getMap(t);

        // 如果map不為空
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);

            // 如果map中已經有該ThreadLocal的值，返回
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }

        // 在沒有map或map中沒有新增該ThreadLocal時呼叫初始化
        return setInitialValue();
    }

    // 初始化
    private T setInitialValue() {
        // 呼叫initialValue獲取預設值
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            // 如果Thread中並沒有map，則新建一個
            // 這裡注意，是每個Thread維護一個ThreadLocalMap
            createMap(t, value);
        return value;
    }

    // 賦值
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            // 這裡同樣有可能呼叫建立ThreadLocalMap
            createMap(t, value);
    }

     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

     // 返回Thread中維護的TreadLocalMap
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    // 如果Thread中並沒有map，則新建一個
    // 這裡注意，是每個Thread維護一個ThreadLocalMap
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
}

四、總結

ThreadLocal類最重要的一個概念是，其原理是通過一個ThreadLocal的靜態內部類ThreadLocalMap實現，但是實際中，ThreadLocal不儲存ThreadLocalMap，而是有每個Thread內部維護ThreadLocal.ThreadLocalMap threadLocals一份資料結構。

這裡畫張圖更容易理解，假如我們有如下的程式碼

class ThreadLocalDemo
{
    ThreadLocal<Integer> localA = new ThreadLocal<Integer>();
    ThreadLocal<Integer> localB = new ThreadLocal<Integer>();
}

在多執行緒環境下，資料結構應該是如下圖所示