Java併發（二十）：線程本地變量ThreadLocal

ThreadLocal是一個本地線程副本變量工具類。

主要用於將私有線程和該線程存放的副本對象作一個映射，各個線程之間的變量互不干擾，在高併發場景下，能夠實現無狀態的調用，特別適用於各個線程依賴不一樣的變量值完成操做的場景。

讀寫鎖ReentrantReadWriteLock 記錄線程持有的讀鎖數量時使用了ThreadLocal。Java併發（十）：讀寫鎖ReentrantReadWriteLock

1、ThreadLocal的核心機制

每一個Thread線程內部都有一個Map，Tread類的ThreadLocal.ThreadLocalMap屬性

Map裏面存儲線程本地對象（key也就是當前的ThreadLoacal對象）和線程的變量副本（value）

Thread內部的Map是由ThreadLocal維護的，由ThreadLocal負責向map獲取和設置線程的變量值

數據結構：

2、ThreadLocal源碼分析

 ThreadLocal核心方法：

• get()：返回此線程局部變量的當前線程副本中的值。
• initialValue()：返回此線程局部變量的當前線程的「初始值」。
• remove()：移除此線程局部變量當前線程的值。
• set(T value)：將此線程局部變量的當前線程副本中的值設置爲指定值。

內部類 ThreadLocalMap：

      static class Entry extends WeakReference<ThreadLocal<?>> {
          /** The value associated with this ThreadLocal. */
          Object value;

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

Entry繼承自WeakReference（弱引用，生命週期只能存活到下次GC前），但只有Key是弱引用類型的，Value並不是弱引用。

ThreadLocalMap的set()方法：

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

        ThreadLocal.ThreadLocalMap.Entry[] tab = table;
        int len = tab.length;

        // 根據 ThreadLocal 的散列值，查找對應元素在數組中的位置
        int i = key.threadLocalHashCode & (len-1);

        // 採用「線性探測法」，尋找合適位置
        for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
            e != null;
            e = tab[i = nextIndex(i, len)]) {

            ThreadLocal<?> k = e.get();

            // key 存在，直接覆蓋
            if (k == key) {
                e.value = value;
                return;
            }

            // key == null，可是存在值（由於此處的e != null），說明以前的ThreadLocal對象已經被回收了
            if (k == null) {
                // 用新元素替換陳舊的元素
                replaceStaleEntry(key, value, i);
                return;
            }
        }

        // ThreadLocal對應的key實例不存在也沒有陳舊元素，new 一個
        tab[i] = new ThreadLocal.ThreadLocalMap.Entry(key, value);

        int sz = ++size;

        // cleanSomeSlots 清楚陳舊的Entry（key == null）
        // 若是沒有清理陳舊的 Entry 而且數組中的元素大於了閾值，則進行 rehash
        if (!cleanSomeSlots(i, sz) && sz >= threshold)
            rehash();
    }

ThreadLocalMap中解決Hash衝突的方式並不是鏈表的方式，而是採用線性探測的方式，所謂線性探測，就是根據初始key的hashcode值肯定元素在table數組中的位置，若是發現這個位置上已經有其餘key值的元素被佔用，則利用固定的算法尋找必定步長的下個位置，依次判斷，直至找到可以存放的位置。

ThreadLocalMap解決Hash衝突的方式就是簡單的步長加1或減1，尋找下一個相鄰的位置。

顯然ThreadLocalMap採用線性探測的方式解決Hash衝突的效率很低，若是有大量不一樣的ThreadLocal對象放入map中時發送衝突，或者發生二次衝突，則效率很低。

因此這裏引出的建議是：每一個線程只存一個變量，這樣的話全部的線程存放到map中的Key都是相同的ThreadLocal，若是一個線程要保存多個變量，就須要建立多個ThreadLocal，多個ThreadLocal放入Map中時會極大的增長Hash衝突的可能。

get()方法：

步驟：
（1）獲取當前線程的ThreadLocalMap對象threadLocals
（2）從map中獲取線程存儲的K-V Entry節點。
（3）從Entry節點獲取存儲的Value副本值返回。
（4）map爲空的話返回初始值null，即線程變量副本爲null，在使用時須要注意判斷NullPointerException。

    public T get() {
        // 獲取當前線程
        Thread t = Thread.currentThread();

        // 獲取當前線程的成員變量 threadLocal
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            // 從當前線程的ThreadLocalMap獲取相對應的Entry
            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;
    }

set()方法：

步驟：
（1）獲取當前線程的成員變量map
（2）map非空，則從新將ThreadLocal和新的value副本放入到map中。
（3）map空，則對線程的成員變量ThreadLocalMap進行初始化建立，並將ThreadLocal和value副本放入map中。

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

void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

 initialValue()方法：

該方法定義爲protected級別且返回爲null，很明顯是要子類實現它的，因此咱們在使用ThreadLocal的時候通常都應該覆蓋該方法。該方法不能顯示調用，只有在第一次調用get()或者set()方法時纔會被執行，而且僅執行1次。

 protected T initialValue() {
        return null;
    }

3、使用場景

簡單使用場景一：

public class SeqCount {

    private static ThreadLocal<Integer> seqCount = new ThreadLocal<Integer>(){
        // 實現initialValue()
        public Integer initialValue() {
            return 0;
        }
    };

    public int nextSeq(){
        seqCount.set(seqCount.get() + 1);

        return seqCount.get();
    }

    public static void main(String[] args){
        SeqCount seqCount = new SeqCount();

        SeqThread thread1 = new SeqThread(seqCount);
        SeqThread thread2 = new SeqThread(seqCount);
        SeqThread thread3 = new SeqThread(seqCount);
        SeqThread thread4 = new SeqThread(seqCount);

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }

    private static class SeqThread extends Thread{
        private SeqCount seqCount;

        SeqThread(SeqCount seqCount){
            this.seqCount = seqCount;
        }

        public void run() {
            for(int i = 0 ; i < 3 ; i++){
                System.out.println(Thread.currentThread().getName() + " seqCount :" + seqCount.nextSeq());
            }
        }
    }
}

 運行結果：

　　Thread-1 seqCount :1
　　Thread-3 seqCount :1
　　Thread-3 seqCount :2
　　Thread-3 seqCount :3
　　Thread-0 seqCount :1
　　Thread-0 seqCount :2
　　Thread-0 seqCount :3
　　Thread-2 seqCount :1
　　Thread-1 seqCount :2
　　Thread-1 seqCount :3
　　Thread-2 seqCount :2
　　Thread-2 seqCount :3

相似的ReentrantReadWriteLock中的java.util.concurrent.locks.ReentrantReadWriteLock.Sync.readHolds屬性，也使用的了TreadLocal來記錄佔有該讀鎖的線程重入次數。可參考：Java併發（十）：讀寫鎖ReentrantReadWriteLock

注意：initialValue()方法返回一個對象時，get()和set()方法操做的實際上是同一個對象的屬性，不能實現線程隔離。

使用場景二：session獲取場景

每一個線程訪問數據庫都應當是一個獨立的Session會話，若是多個線程共享同一個Session會話，有可能其餘線程關閉鏈接了，當前線程再執行提交時就會出現會話已關閉的異常，致使系統異常。此方式能避免線程爭搶Session，提升併發下的安全性。

//獲取Session
public static Session getCurrentSession(){
    Session session =  threadLocal.get();
    //判斷Session是否爲空，若是爲空，將建立一個session，並設置到本地線程變量中
    try {
        if(session ==null&&!session.isOpen()){
            if(sessionFactory==null){
                rbuildSessionFactory();// 建立Hibernate的SessionFactory
            }else{
                session = sessionFactory.openSession();
            }
        }
        threadLocal.set(session);
    } catch (Exception e) {
        // TODO: handle exception
    }

    return session;
}

4、內存泄漏問題

ThreadLocalMap使用ThreadLocal的弱引用做爲key，若是一個ThreadLocal沒有外部強引用來引用它，那麼系統 GC 的時候，這個ThreadLocal勢必會被回收，這樣一來，ThreadLocalMap中就會出現key爲null的Entry，就沒有辦法訪問這些key爲null的Entry的value，若是當前線程再遲遲不結束的話，這些key爲null的Entry的value就會一直存在一條強引用鏈：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永遠沒法回收，形成內存泄漏。

關於GC以及引用狀態：JVM垃圾回收機制

其實，ThreadLocalMap的設計中已經考慮到這種狀況，也加上了一些防禦措施：在ThreadLocal的get(),set(),remove()的時候都會清除線程ThreadLocalMap裏全部key爲null的value。

可是這些被動的預防措施並不能保證不會內存泄漏：

　　使用static的ThreadLocal，延長了ThreadLocal的生命週期，可能致使的內存泄漏。
　　分配使用了ThreadLocal又再也不調用get(),set(),remove()方法，那麼就會致使內存泄漏。

內存泄漏實例分析：ThreadLocal 內存泄露的實例分析 

解決：

每次使用完ThreadLocal，都調用它的remove()方法，清除數據。

在使用線程池的狀況下，沒有及時清理ThreadLocal，不只是內存泄漏的問題，更嚴重的是可能致使業務邏輯出現問題。因此，使用ThreadLocal就跟加鎖完要解鎖同樣，用完就清理。

 

 

參考資料 / 相關推薦

線程管理（九）使用本地線程變量

不共享有時是最好的

【死磕Java併發】—–深刻分析ThreadLocal

Java併發編程：深刻剖析ThreadLocal

ThreadLocal-面試必問深度解析

深刻分析 ThreadLocal 內存泄漏問題

ThreadLocal 內存泄露的實例分析