併發編程：ThreadLocal用法及原理

與Synchonized的對照: ThreadLocal和Synchonized都用於解決多線程併發訪問。可是ThreadLocal與synchronized有本質的差別。synchronized是利用鎖的機制，使變量或代碼塊在某一時該僅僅能被一個線程訪問。而ThreadLocal爲每個線程都提供了變量的副本，使得每個線程在某一時間訪問到的並非同一個對象，這樣就隔離了多個線程對數據的數據共享。而Synchronized卻正好相反，它用於在多個線程間通信時可以獲得數據共享。

Synchronized用於線程間的數據共享，而ThreadLocal則用於線程間的數據隔離。

用法

把要線程隔離的數據放進ThreadLocal

static ThreadLocal<T> threadLocal = new ThreadLocal<T>() {
    protected T initialValue() {
        這裏一般new一個對象返回
    }
}

線程獲取相關數據的時候只要

threadLocal.get();

想修改、賦值只要

threadLocal.set(val)

使用場景

如上面說到的，ThreadLocal是用於線程間的數據隔離，ThreadLocal爲每個線程都提供了變量的副本。

• 舉例1：聯想一下服務器（例如tomcat）處理請求的時候，會從線程池中取一條出來進行處理請求，如果想把每個請求的用戶信息保存到一個靜態變量裏以便在處理請求過程中隨時獲取到用戶信息。這時候可以建一個攔截器，請求到來時，把用戶信息存到一個靜態ThreadLocal變量中，那麼在請求處理過程中可以隨時從靜態ThreadLocal變量獲取用戶信息。
• 舉例2：Spring的事務實現也藉助了ThreadLocal類。Spring會從數據庫連接池中獲得一個connection，然會把connection放進ThreadLocal中，也就和線程綁定了，事務需要提交或者回滾，只要從ThreadLocal中拿到connection進行操作。

原理分析

1、get()方法

public T get() {
     Thread t = Thread.currentThread();
     ThreadLocalMap map = getMap(t);
     if (map != null) {//當map已存在
         ThreadLocalMap.Entry e = map.getEntry(this);
         if (e != null) {
             @SuppressWarnings("unchecked")
             T result = (T)e.value;
             return result;
        }
    }
    return setInitialValue();//初始化值
}

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

上面先取到當前線程，然後調用getMap方法獲取對應的ThreadLocalMap，ThreadLocalMap是ThreadLocal的靜態內部類，然後Thread類中有一個這樣類型成員，所以getMap是直接返回Thread的成員

ThreadLocal.ThreadLocalMap threadLocals = null;

來看下ThreadLocal的內部類ThreadLocalMap源碼，留個大致印象

static class ThreadLocalMap {
     private static final int INITIAL_CAPACITY = 16;//初始數組大小
     private Entry[] table;//每個可以擁有多個ThreadLocal
     private int size = 0;
     private int threshold;//擴容閥值
     static class Entry extends WeakReference<ThreadLocal<?>> {
         Object value;
 
         Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }

    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 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) {
                    //循環利用key過期的Entry
                replaceStaleEntry(key, value, i);
                return;
            }
        }
        tab[i] = new Entry(key, value);
        int sz = ++size;
        if (!cleanSomeSlots(i, sz) && sz >= threshold)
            rehash();
    }
｝

可以看到有個Entry內部靜態類，它繼承了WeakReference，總之它記錄了兩個信息，一個是ThreadLocal<?>類型，一個是Object類型的值。getEntry方法則是獲取某個ThreadLocal對應的值，set方法就是更新或賦值相應的ThreadLocal對應的值。裏面涉及到擴容策略、Entry哈希衝突、循環利用等等不再深入，留個大致印象就好。

回顧下get()方法中的代碼

if (map != null) {
    ThreadLocalMap.Entry e = map.getEntry(this);
    if (e != null) {
        @SuppressWarnings("unchecked")
        T result = (T)e.value;
        return result;
7   }
}
return setInitialValue();

map爲null或e爲null就會走到setInitialValue，如果我們是第一次get()方法，那map會是空的，所以接下來先看setInitialValue()方法

private T setInitialValue() {
         //調用我們實現的方法得到需要線程隔離的值
     T value = initialValue();
     Thread t = Thread.currentThread();
     //拿到相應線程的ThreadLocalMap成員變量
     ThreadLocalMap map = getMap(t);
     if (map != null)
         map.set(this, value);
     else
        createMap(t, value);
    return value;
}

上面initialValue就是實例化ThreadLocal要實現的方法，這裏又取了線程的ThreadLocalMap，不爲空就把值set進去（鍵爲TreadLocal本身，值就是initialValue返回的值）；爲空就創建一個map同時添加一個值進去,最後返回value。

map.set(this, value)這句代碼在上面的ThreadLocalMap源碼中可以看到大致流程，下面看看createMap()做了什麼事

void createMap(Thread t, T firstValue) {
     t.threadLocals = new ThreadLocalMap(this, firstValue);
 }
 
 
 ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
     table = new Entry[INITIAL_CAPACITY];
     int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
         //創建一個Entry，加入數組
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    setThreshold(INITIAL_CAPACITY);
}

可以看到在new ThreadLocalMap之後，就會創建一個Entry加入到數組中，最後把ThreadLocalMap的引用賦值給Thread的threadLocals成員變量

在回顧下get()方法中的代碼

if (map != null) {
    ThreadLocalMap.Entry e = map.getEntry(this);
    if (e != null) {
        @SuppressWarnings("unchecked")
        T result = (T)e.value;
        return result;
    }
}
return setInitialValue();

現在map不會爲空了，再次調用get方法就會調用map的getEntry方法（上面的ThreadLocalMap源碼中可以看到大致流程），拿到相應的Entry，然後就可以拿到相應的值返回出去

2、set方法

分析完get()方法，那麼set()方法就自然而然的明白了，就不再贅述

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

總結

原理

ThreadLocal的實現原理是，在每個線程中維護一個Map，鍵是ThreadLocal類型，值是Object類型。當想獲取ThreadLocal的值時，就從當前線程中拿出Map，然後在把ThreadLocal本身作爲鍵從Map中拿出值返回。

優缺點

優點：

提供線程內的局部變量。每個線程都自己管理自己的局部變量，互不影響

缺點：

內存泄漏問題。可以看到ThreadLocalMap中的Entry是繼承WeakReference的，其中ThreadLocal是以弱引用形式存在Entry中，如果ThreadLocal在外部沒有被強引用，那麼垃圾回收的時候就會被回收掉，又因爲Entry中的value是強引用，就會出現內存泄漏。雖然ThreadLocal源碼中的會對這種情況進行了處理，但還是建議不需要用TreadLocal的時候，手動調remove方法。

最後：
我做開發十多年的時間，如果大家對於學習java的學習方法，學習路線以及你不知道自己應該是自學還是培訓的疑問，都可以隨時來問我，大家可以加我的java交流學習qun：615-741-636。qun內有學習教程以及開發工具。